Download - Strukturalt Programozas c#
Készítette: Subecz Zoltán, Szolnoki Főiskola, http://suzo.uw.hu, [email protected]
Strukturált programozásC# Console módban
Házi feladat:Néhány példához folyamatábrát és algoritmust - pszeudokódot készíteni.Többhöz pszeudokódot és kevesebbhez folyamatábrát.
TartalomjegyzékBevezetés.......................................................................................................................................................21. Alapok.......................................................................................................................................................42. Tömbök...................................................................................................................................................213. Néhány kiegészítő példa........................................................................................................................294. Karakter típus........................................................................................................................................355. Karakterláncok ( Stringek )..................................................................................................................386. Metódusok, Eljárások, függvények......................................................................................................457. ArrayList – List ( lista ).........................................................................................................................548. Struktúra ( Rekord, Struct ).................................................................................................................579. Fájlkezelés...............................................................................................................................................5910. Kivételkezelés.......................................................................................................................................6511.Lépésenkénti futtatás-Nyomkövetés...................................................................................................7012. Egyéb.....................................................................................................................................................71
Ajánlott irodalom:
- James Foxall: Tanuljuk meg a Visual C# 2008 használatát 24 óra alattKiskapu KiadóA Főiskola könyvtárában és a Jegyzetboltban is megtalálható.
http://csharptk.ektf.hu
Reiter István: C#:http://people.inf.elte.hu/reiter_i/sharp.htmlhttp://devportal.hu/content/CSharpjegyzet.aspx
Illés Zoltán könyve:Google: illés zoltán c# filetype:pdf
http://compalg.inf.elte.hu/~tony/Informatikai-Konyvtar/09-Programozas%20C-sharp%20nyelven/Programozas-Csharp-nyelven-Konyv.pdf
C# mesteri szinten 21 nap alatt.rar Interneten több helyről letölthető. => Googlepl.http://eduzso.freeiz.com/files/masodik_ev/I/prog1-2/C%20mesteri%20szinten%2021%20nap%20alatt/
http://dragon.ektf.hu/ebooks/ => Magasszintű Programozási Nyelvek I. Feladatgyűjtemény
Chuck Sphar-Stephen Randy Davis: C# 2008Tantusz Könyvek sorozat, Panem Kiadó
http://hu.wikipedia.org/wiki/C_Sharp_programoz%C3%A1si_nyelv
1
http://csharp.lap.huhttp://nyelvek.inf.elte.hu/leirasok/Csharp/index.php
Bevezetés
Sok fajta programozási nyelv van. Ilyen nyelv az SQL is, amit már megismertek. Vannak speciális célú programozási nyelvek, amelyeket egy részterületre fejlesztettek ki, és vannak általános célú programozási nyelvek.
http://hu.wikipedia.org/wiki/Programoz%C3%A1si_nyelvhttp://hu.wikipedia.org/wiki/Programoz%C3%A1si_nyelvek_kateg%C3%B3ri%C3%A1k_szerinthttp://wiki.prog.hu/wiki/Programoz%C3%A1si_nyelvhttp://wiki.prog.hu/wiki/Programoz%C3%A1si_nyelvek_list%C3%A1jahttp://wiki.hup.hu/index.php/Programoz%C3%A1si_nyelvhttp://programozas.lap.hu
A C# korszerű, modern a Microsoft által kifejlesztett programozási nyelv. A C# napjaink egyik kedvelt programozási nyelve.
A Windows programozásához fejlesztették ki. Mivel a teljes Windows programozására alkalmas, ezért ilyen nagy méretű.
Néhány másik népszerű nyelv:Pascal nyelv: http://hu.wikipedia.org/wiki/Pascal
http://pascal.lap.hu/Egy ingyenes Pascal fejlesztő és fordító:
www.freepascal.org
C++ nyelv: http://hu.wikipedia.org/wiki/C%2B%2Bhttp://cplusplus.lap.hu/Egy ingyenes C++ fejlesztő és fordító:
Dev C++: http://www.bloodshed.net/devcpp.html
A C# nem egyből a processzor számára azonnal futtatható natív kódot fordít, hanem egy úgynevezett köztes kódot a .NET keretrendszer számára.(Tehát hasonlóan működik, mint a Java )
A C# (a Visual Basic mellett) a .NET keretrendszer egyik fő programozási nyelve.
A .NET az XP-ben még nincs alapból benne, de a Vistában már benne van. A C# telepítésekor automatikusan felteszi a .NET keretrendszert XP-nél is. De ha egy másik gépen szeretnénk futtatni programunkat, amelyiken XP van, akkor a .NET keretrendszert előtte fel kell telepíteni.
Az .NET ingyenesen letölthető a www.microsoft.com honlapról.A .NET keretrendszernek is van több verziója.Keresőbe beírva: .net framework => megadja a pontos letöltési helyet.
.net framework 3.0 => Windows XP SP2 kell hozzá
.net framework 4.0 => Windows XP SP3 kell hozzá
2
A .NET keretrendszerben is benne van a C# fordító. (C# compiler) (csc.exe). Így a programjaink fordítását a Visual Studio fejlesztőkörnyezet nélkül is meg tudnánk oldani. ( Lásd. 1. fejezet: Alapok vége )Így az 500Mb feltelepítése helyett (Visual Studio) elég lenne a 3Mb ( .NET ) feltelepítése is.A grafikus programok készítését is meg tudnánk oldani a Visual Studio fejlesztőkörnyezet nélkül is.De mivel a grafikus programok készítéséhez nagyon hasznos a grafikus fejlesztő környezet, ezért
otthonra is telepítsék fel az ingyenes C# fejlesztő környezetet:http://www.microsoft.com/visualstudio/en-us/products/2008-editions/express
Innen elég csak a Visual C# 2008 Express Edition – t feltelepíteni.
http://hu.wikipedia.org/wiki/C_Sharp_programoz%C3%A1si_nyelvoldalról:
C#
A C# a Microsoft által a .NET keretrendszer részeként kifejlesztett objektumorientált programozási nyelv. A nyelv alapjául a C++ és a Java szolgált. A C#-ot úgy tervezték, hogy meglegyen az egyensúly a fejlesztő nyelvi szabadsága és a gyors alkalmazásfejlesztés lehetősége között.
A C# nagyon hasonlít a Java nyelvhez, de könnyebb a használata.
A C# az a programozási nyelv, ami a legközvetlenebb módon tükrözi az alatta működő, minden .NET programot futtató .NET keretrendszert, valamint erősen függ is attól: nincsen nem menedzselt, natív módban futó C# program. A primitív adattípusai objektumok, a .NET típusok megfelelői. Szemétgyűjtést használ, valamint az absztrakcióinak többsége (osztályok, interfészek, delegáltak, kivételek…) a .NET futtatórendszert használja közvetlen módon.
A C-hez hasonlóan a kis- és nagybetűk itt is különböznek, tehát ValtozoNev és a valtozonev két különböző dolgot jelent majd.(ez a pascalosok számára lehet majd zavaró, de meg lehet szokni)
3
1. Alapok
Bevezetés: A C# futtatását, fordítását 2 módon tehetjük meg:a, A C# fejlesztő környezettel.b, A fejlesztőkörnyezet nélküli csc.exe-vel
Mivel a .NET keretrendszerben is benne van a C# fordító. (C# compiler) (csc.exe). Ezért a programjaink fordítását a C# fejlesztőkörnyezet nélkül is meg tudnánk oldani.A Visual Studio C# fejlesztőkörnyezetet nem is kellene hozzá feltelepíteni csak a .NET keretrendszert.Aki akarja, választhatja a fordításnak ezt a módját órán is.( 1. fejezet végén megnézzük.)
a, A C# fejlesztő környezettel:C# indítása után:File menü/ New Project / Console Application
Adjunk nevet a projectnek, elérési utat, majd kattintsunk az OK gombra
VAGY: File menü/ New Project / Console Application után:File menü => Save All => Könyvtár kiválasztása
Ez, vagy ehhez hasonló jelenik meg a szerkesztői ablakban:
using System;using System.Collections.Generic;using System.Linq;using System.Text;
namespace ConsoleApplication1{ class Program { static void Main(string[] args) { } }}
Ebből először sok minden elhagyható, de benne is maradhat minden.
1/1. példaLegegyszerűbb futó C# program:
class proba { static void Main() {
} }
4
class: osztály megadása ( majd az Objektumorientált Programozás, OOP tantárgyban lesz részletesen. )nevet kell adni az osztálynak, itt probaOsztálydeklaráció megadása. Publikus, azaz bármely más projekt szabadon használhatja az osztályt.
void: eljárás ( az OOP-ben metódusnak hívják )static: az OOP-hez ( class, osztály ) kapcsolódó fogalom. Majd ott megnézzük.
{…}: részek összefogása, csoportosítás
Main(): a program fő eljárása ( metódusa ).Ez a program belépési pontja, ahol a program végrehajtása megkezdődik.
Futtatás: Debug menü/Start Debuging, vagy F5, vagy Start Debuging ikon az eszköztáron.
fut - nem ír ki semmit - visszaugrik a szerkesztő képernyőre.
1/2. PéldaÍrassuk ki a képernyőre, hogy Hello, és várjon billentyűleütésre.
class proba2 { static void Main() { System.Console.WriteLine("Hello"); System.Console.ReadLine(); } }
System egy előre definiált névtér ( namespace )Névtér: OOP-ben lesz róla szóA rendszer által tartalmazott utasításokat itt tárolja.
Console: A System névtér egy osztálya, amit a Console Alkalmazásoknál (Console Applications ) az Inpu/Outputra használunk.
A Console egy rendszerobjektum, ami egy parancssort jelképez. A Console objektum WriteLine metódusának meghívása a paraméterként átadott szöveget kiírja a parancssorba.
WriteLine: A Console osztály eljárása ( metódusa ), a paraméterként átadott szöveget kiírja a parancssorba. + soremelés!ReadLine: hasonlóan: egy sor szöveget olvas be a billentyűzetről.
itt használata: Enter leütésre vár.A System.Console.ReadLine(); utasítás nélkül: kiírná a szöveget a képernyőre, de visszaugrana a szerkesztő képernyőre.
Ha a program elejére kiírjuk, hogy using System;, akkor az utasítások elé nem kell kiírni, hogy System.:
using System; class proba2 { static void Main() { Console.WriteLine("hello"); Console.ReadLine();
5
} }
1/3. Példa Írjuk ki egymás alá 3 sorba: Hello1, Hello2, Hello3
using System; class proba2 {
static void Main() {
Console.WriteLine("Hello1\nHello2\nHello3"); Console.ReadLine(); }}
Az egyszerűség miatt a Main()-en kívüli részt nem írom ki.
1/4. PéldaVegyünk fel 2 egész változót: b=5,a=3Írassuk ki 5 sorba: Hello1,a-változó,Hello2,b-változó,Hello3
static void Main() { int b=5,a=3;
// A tisztán OOP nyelvekben (mint a C# és a Java), minden objektum// adattagok + metódusok// Egy egyszerű változó is.// Ha itt beírjuk, hogy a. akkor egyből mutatja a metódusait.
Console.WriteLine("Hello1\n"+a+"\nHello2\n"+b+"\nHello3"); Console.ReadLine(); }
1/5.példaÍrassuk ki 10-szer egymás alá, hogy Hello, majd Enter leütés után képernyőtörlés, majd írassuk ki 1-től 15-ig az egészeket egymás alá.
static void Main() { int a; for(a=1;a<=10;a++) Console.WriteLine("Hello"); Console.ReadLine(); Console.Clear(); for(a=1;a<=15;a++) Console.WriteLine(a); Console.ReadLine(); }
a++: mint a=a+1
6
1/6. PéldaÍrassuk ki egymás alá 30-tól 50-ig az egészeket. A végén írassuk ki a ciklusváltozó értékét.
static void Main() { int a; for(a=30;a<=50;a++) Console.WriteLine(a);
Console.WriteLine(a); // 51-et ír ki Console.ReadLine(); }
Így is lehet használni: for (int a = 30; a <= 50; a++)De ilyenkor az „a” változót csak a ciklusban látja. Ezért az utolsó Console.WriteLine(a); utasításnál hibát ír ki.
1/7.példaÍrassuk ki a 15-től -10-ig a számokat egymás mellé space-el elválasztva.
static void Main() { int a; for (a = 15; a >= -10; a--) Console.Write(a+" "); Console.ReadLine(); }
1/8.példaÍrassuk ki a páros számokat egymás alá 210-től 234-ig.
static void Main() { int a; for (a = 210; a <=234; a=a+2) Console.WriteLine(a); Console.ReadLine(); }
1/9.példaÍrassuk ki a páratlan számokat egymás alá 95-től 73-ig.
static void Main() { int a; for (a = 95; a >=73; a=a-2) Console.WriteLine(a); Console.ReadLine(); }
1/10.példaAdjuk össze a számokat 20-tól 50-ig. A végén írassuk ki az eredményt.
static void Main() {
7
int a, osszeg=0; for (a = 20; a <= 50; a++) osszeg = osszeg + a; Console.WriteLine("20-tól 50-ig a számok összege= "+osszeg); Console.ReadLine(); }
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:- Adjuk össze a -153-tól 247-ig a páratlan számokat. A végén írassuk ki az eredményt.
1/11.példaÍrassa ki a számokat 1-től 100-ig egymás alá oldalanként.Egy oldalon 20 sor legyen. Oldalanként billentyűleütésre várjon+képernyőtörlés.
static void Main() { int a; for (a = 1; a <= 100; a++) { Console.WriteLine(a); if(a % 20==0) // %: osztás maradéka { Console.WriteLine("Nyomjon Enter-t!"); Console.ReadLine(); Console.Clear(); } } Console.ReadLine(); }
1/12.példaMit ír ki?
static void Main() { Console.WriteLine(7 / 3); // -> 2
// a / egész számoknál az osztás egész részét jelenti.Console.WriteLine(7.0 / 3); // -> 2,333333333333333
// ! tizedes vessző van és nem tizedes pontConsole.WriteLine("{0,5:f3}",7.0/3); // ->2,333Console.WriteLine((double) 7/ 3); // -> 2,333333333333333
int a, b; a = 7; b = 3;
Console.WriteLine("a= " + a + "\nb= " + b); //->a= 7 b=3 (2 sorban)
Console.WriteLine("a= {0}\nb= {1}",a,b);// mint az előző
Console.WriteLine(a/b); // -> 2Console.WriteLine((double) a/b); // -> 2,333333333333333
double c;
8
c = 7;Console.WriteLine(c/b); //-> 2,333333333333333
c = a / b; Console.WriteLine(c); //-> 2Console.WriteLine((double) c); //-> 2
c = (double) a / b;Console.WriteLine(c); //-> 2,333333333333333
Console.ReadLine(); }
1/13.példaSzámítsuk ki 1-től 25-ig a számok átlagát, és írassuk ki.
static void Main() { int a,osszeg = 0; for (a = 1; a <= 25; a++) osszeg = osszeg + a; Console.WriteLine((double) osszeg/25); Console.ReadLine();
}
1/14.példaOlvasson be egy szöveget a billentyűzetről, majd írja vissza a képernyőre.
static void Main() { string s; Console.Write("Adjon meg egy szöveget\ns= "); s=Console.ReadLine(); Console.WriteLine("A beolvasott szöveg= "+s); Console.ReadLine(); }
A Console.ReadLine() mindig string tipusú eredményt ad vissza.
1/15.példaOlvasson be egy egész számot, és írja ki kétszeresét.
static void Main() { string s; int a; Console.Write("Adjon meg egy egész számot\ns= "); s = Console.ReadLine(); a = Convert.ToInt32(s); Console.WriteLine("A beolvasott szám kétszerese= " +2*a); Console.ReadLine(); }
9
vagy:
int a; a = Convert.ToInt32(Console.ReadLine());
1/16.példaOlvasson be egy valósat és írassa ki a kétszeresét.
static void Main() { Console.Write("Adjon meg egy számot\na= "); double a; a=Convert.ToDouble(Console.ReadLine()); Console.WriteLine("A beolvasott szám kétszerese= " +2*a); Console.ReadLine(); }
! beolvasásnál is tizedes vessző van és nem tizedes pont.
1/17.példaOlvasson be egy pozitív egészet. Írassa ki 1-től a számig az egészeket egymás alá.
static void Main() { int a, b; Console.Write("Adjon meg egy egészet!\na= "); a = Convert.ToInt32(Console.ReadLine()); for (b = 1; b <= a; b++) Console.WriteLine(b); Console.ReadLine(); }
1/18.példaOlvasson be egy pozitív egészet. Adja össze 1-től a beolvasott számig az egészeket.Írja ki az összeget és a számok átlagát.
static void Main() { int a, b,osszeg=0; Console.Write("Adjon meg egy egészet!\na= "); a = Convert.ToInt32(Console.ReadLine()); for (b = 1; b <= a; b++) osszeg = osszeg + b; Console.WriteLine("A beolvasott számig a számok összege= " + osszeg + "\nés átlaga= " + (double) osszeg / a); Console.ReadLine(); }
1/19.példaOlvasson be egy pozitív egészet. Írassa ki a szám osztóit egymás alá
static void Main() {
10
int a, b; Console.Write("Adjon meg egy egészet!\na= "); a = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("A beolvasott szám osztói:"); for (b = 1; b <= a; b++) if (a % b == 0) Console.WriteLine(b); Console.ReadLine(); }
1/20.példaOlvasson be egy egészet. Számolja ki a faktoriálisát. És írassa ki az eredményt.
! az int (előjeles egész) típus a C#-ban 4 byte-os, ami elég a faktoriálishoz.Nincs is nagyobb egész típus.
static void Main() { int a, b,fakt=1; Console.Write("Adjon meg egy egészet!\na= "); a = Convert.ToInt32(Console.ReadLine()); for (b = 2; b <= a; b++) fakt = fakt * b; Console.WriteLine("A szám faktoriálisa= "+fakt); Console.ReadLine(); }
1/21.példaMásodfokú egyenlet gyökeinek kiszámolása:Olvasson be 3 valós számot a billentyűzetről (a, b, c). Számítsa ki ezekre, a megoldó képlettel, a másodfokú egyenlet gyökeit (x1, x2).
static void Main() { double a,b,c,diszk,x1,x2; Console.WriteLine("Másodfokú egyenlet megoldóképletének kiszámolása."); Console.WriteLine("Adja meg a,b és c értékét"); Console.Write("a= "); a = Convert.ToDouble(Console.ReadLine()); Console.Write("b= "); b = Convert.ToDouble(Console.ReadLine()); Console.Write("c= "); c = Convert.ToDouble(Console.ReadLine()); diszk = b * b - 4 * a * c; x1 = (-b + Math.Sqrt(diszk)) / (2 * a); x2 = (-b - Math.Sqrt(diszk)) / (2 * a); Console.WriteLine("Eredmények:\nx1= " + x1 + "\nx2= " + x2); Console.ReadLine(); }
! futtatásnál figyelni, hogy a diszkrimináns ne legyen negatív szám.pl.: a,b pozitív, c negatív.
1/22.példaOlvasson be 3 valós számot. Döntse el, hogy a 3 szám lehet-e egy háromszög 3 oldala.
static void Main()
11
{ double a, b, c; Console.WriteLine("Adjon meg 3 számot"); Console.Write("a= "); a = Convert.ToDouble(Console.ReadLine()); Console.Write("b= "); b = Convert.ToDouble(Console.ReadLine()); Console.Write("c= "); c = Convert.ToDouble(Console.ReadLine()); if (a + b > c && a + c > b && b + c > a) Console.WriteLine("A három szám lehet egy háromszög három oldala."); else Console.WriteLine("A három szám nem lehet egy háromszög három oldala."); Console.ReadLine(); }
1/23.példaÍrasson ki * karakterekből téglalapot. 10 sor, 20 oszlop.
static void Main() { int a, b; for (a = 1; a <= 10; a++) { for (b = 1; b <= 20; b++) Console.Write("*"); Console.WriteLine(); } Console.ReadLine(); }
b, eset: 1 for ciklussal c, eset: a sor és oszlop értékét beolvassukd, eset: b, és c, eset együtt
1/24.példaJelenítse meg az alábbi alakzatot a képernyőn 20 sorban:1x2x3x…1x2x3x…1x2x3x……………
static void Main() { int a, b; for (a = 1; a <= 20; a++) { for (b = 1; b <= 20; b++) Console.Write(b+"x"); Console.WriteLine(); } Console.ReadLine(); }
1/25.példaJelenítse meg az alábbi alakzatot a képernyőn 20 sorban:1x
12
1x2x1x2x3x…………
static void Main() { int a, b; for (a = 1; a <= 20; a++) { for (b = 1; b <= a; b++) Console.Write(b+"x"); Console.WriteLine(); } Console.ReadLine(); }
b, eset: más-más formályú háromszögek kiíratása
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:Írassa ki 1-10-ig egymás alá a számokat és mellé a szám értékének megfelelő számú * karaktert tegyen.
1/26.példaÍrassa ki 3 oszlopban:1. oszlop: számok 1-10 –ig, 2. oszlop: a szám négyzete, 3. oszlop: a szám gyökeLegyen fejléc. Mindhárom oszlop 10 karakter széles legyen. A valós értékeket 3 tizedes jegyen jelenítse meg.
static void Main() { Console.WriteLine("{0,10}{1,10}{2,10}", "szám","négyzet","gyök"); int a, b; for (a = 1; a <= 10; a++) Console.WriteLine("{0,10}{1,10:f3}{2,10:f3}", a, a * a, Math.Sqrt(a)); Console.ReadLine(); }
1/27.példaElöl tesztelős ciklussal írassuk ki 50-től 80-ig a páros számokat egymás alá.
static void Main() { int a=50; while (a <= 80) { Console.WriteLine(a); a = a + 2; } Console.ReadLine(); }
1/28.példa
13
Elöl tesztelős ciklussal: adjuk össze a páratlan számokat 11-től 75-ig.A végén írassuk ki az eredményt.
static void Main() { int a=11,osszeg=0; while (a <= 75) { osszeg = osszeg + a; a = a + 2; } Console.WriteLine("11-től 75-ig a páratlan számok összege= " + osszeg); Console.ReadLine(); }
1/29.példaHátul tesztelő ciklussal: Írassuk ki 20-tó -10-ig az egészeket egymás alá.
static void Main() { int a=20; do { Console.WriteLine(a); a--; } while (a >= -10); Console.ReadLine(); }
Amíg a feltétel igaz, végrehajtja az utasításokat.A feltételt az utasítások után értékeli ki.
1/30.példaHátul tesztelő ciklussal: adjuk össze 50-től 60-ig az egészeket. A végén írassuk ki az összeget, és a számok átlagát.
static void Main() { int a=50,osszeg=0; do { osszeg = osszeg + a; a++; } while (a <=60); Console.WriteLine("50-től 60-ig az egészek összege= " + osszeg+"\nés átlaga= "+(double) osszeg/11); Console.ReadLine(); }
14
1/31.példaOlvassunk be egészeket 15 végjelig (amíg 15-ös szám nem érkezik).Számoljuk meg hány pozitív és hány negatív szám érkezett.
static void Main() { int a,dbpoz=0,dbneg=0; Console.WriteLine("Adj meg számokat 15 végjelig!"); do { a = Convert.ToInt32(Console.ReadLine()); if (a > 0) dbpoz++; if (a < 0) dbneg++; } while (a != 15); Console.WriteLine("A pozitívok darabszáma= " + dbpoz + "\nA negatívok darabszáma= " + dbneg); Console.ReadLine(); }
1/32.példaOlvassunk be egészeket 0 végjelig. A végén írassuk ki a beolvasott számok darabszámát,összegét, és átlagát. A lezáró 0-át ne számolja bele. Kezelje azt is, ha csak 1 db 0-át olvasunk be, hogy ne legyen 0-ával osztás.
static void Main() { Console.WriteLine("Adjon meg egészeket 0 végjelig"); int a, db=0, osszeg=0; do { a = Convert.ToInt32(Console.ReadLine()); db++; osszeg = osszeg + a; } while (a != 0); db--; Console.WriteLine("A beolvasott számok darabszáma= "+db); Console.WriteLine("összege= "+osszeg); if(db!=0) Console.WriteLine("átlaga= "+(double) osszeg/db); else Console.WriteLine("Átlag értelmetlen"); Console.ReadLine(); }
15
1/33.példaOlvassunk be egész számokat 0 végjelig. A végén írassuk ki a legnagyobb számot. A lezáró 0-át ne számolja bele.
static void Main() { int a; Console.WriteLine("Adj meg számokat 0 végjelig!"); a = Convert.ToInt32(Console.ReadLine()); int legn = a; while (a != 0) { a = Convert.ToInt32(Console.ReadLine()); if(a!=0) if (a > legn) legn = a; //VAGY az utolsó két IF helyett: if (a > legn && a!=0) legn = a; } Console.WriteLine("A legnagyobb a beolvasottak közül:"+legn); Console.ReadLine(); }
1/34.példaAz ablak háttérszínét állítsuk kékre. Piros betűkkel, sárga háttérrel írassuk ki, hogy Hello.
static void Main() { Console.BackgroundColor = ConsoleColor.Blue; Console.Clear(); Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Hello"); Console.ReadLine(); }
! A Console módban csak 16 féle szín közül lehet válsztani. A karakteres felületek tulajdonságát jól tükrözi. (Unix, Dos). Grafikus módban majd több millió fajta színt ki lehet keverni az RGB összetevőkkel.Ezzel bármilyen színezést meg lehet valósítani.
1/35. példaBreak: Hatására befejeződik a while, do, for vagy switch utasítás végrehajtása.
static void Main(){ int i; for (i = 1; i <= 10; i++) { Console.WriteLine(i); if (i == 5) break; } Console.WriteLine(i); Console.ReadLine();}
16
Kiírja 1-5-ig a számokat, majd még egyszer kiírja az 5-öt.
Néhány, a C# nyelvben használatos, egyszerű típus!
típus Méret Értéktartomány A típusban tárolható adatokbyte 1 byte 0 tól 255 ig Előjel nélküli egész számokint 4 byte -2,147,483,648 tól 2,147,483,647 ig előjeles egész számokfloat 4 byte ±1.5 × 10^−45 tól±3.4 × 10^38-ig Valós(lebegőpontos) számokdouble 8 byte ±5.0 × 10^−324 től ±1.7 × 10^308-ig Valós(lebegőpontos) számokdecimal 16 byte ±1.0 × 10^−28 tól ±7.9 × 10^28-ig Valós(lebegőpontos) számokbool 1 byte true/false True, false értékekchar 2 byte U+0000 tól U+ffff ig Unicode karakterek
1/36 példa
Kiíratáskor néhány vezérlő jel:
\b Backspace\t vízszintes tabulátor\\ Fordított perjel\’ Aposztróf\” Idézıjel\n Sortörés
Például: Írassuk ki a számokat 1-tól 10-ig, de mindegyik után ugorjunk egy Tabulátort.
static void Main(){ for (int i = 1; i <= 10; i++) Console.Write(i + "\t"); Console.ReadLine();}
Exe fájl készítése....Build => az exe fájl megkereshető, és kipróbálható.…\bin\Release könyvtárból
Más könyvtárakba is készít exe részmegoldásokat.
17
Program fordítása a fejlesztőkörnyezet nélküli csc.exe-vel
Mivel a .NET keretrendszerben is benne van a C# fordító. (C# compiler) (csc.exe). Ezért a programjaink fordítását a C# fejlesztőkörnyezet nélkül is meg tudjuk oldani.A Visual Studio C# fejlesztőkörnyezetet nem is kellene hozzá feltelepíteni csak a .NET keretrendszert.
Először meg kell keresni a csc.exe fájl helyét. pl.:c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727
a, Ebbe a könyvtárba készítem el a proba.cs fájlt. Pl. Jegyzettömbbel, vagy pl. Notepad++ segéd-programmal:
using System;namespace proba1{ class proba2 { static void Main() { Console.WriteLine("Hello"); Console.ReadLine(); } }}
Mentés => DOS parancssorba: csc proba.cs => elkészíti a proba.exe programfájlt, ami már futtatható: proba
b., Létrehozok egy könyvtárat pl. c:\munka ahova majd elkészítem a proba.cs forrásfájlt.A csc.exe könyvtár útvonalát hozzáadom a PATH környezeti változóhoz, így a csc.exe bárhonnan
futtatható lesz:A path utasítás (DOS ablakba) mutatja a PATH aktuális állapotát.
pl. készítek egy utvonal.bat fájlt:Set PATH=%PATH%;c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727
Mint az a., esetben: csc proba.cs => elkészíti a proba.exe programfájlt, ami már futtatható: proba
Néhány segédablak:
View => Solution Explorer: itt vannak a project file –jai.Class View: Az osztályokat mutatja.
Már most érdemes megnézni a 11.Lépésenkénti futtatás-Nyomkövetés, mert hasznos a hibakeresésnél.
18
Struktúrált programozás paradigma
• Struktúrált programnak tekintjük azokat a programokat, amelyek csak a megengedett elemi programokat tartalmazzák a megengedett programkonstrukciók alkalmazásával• Elemi programok– üres program– hibás program/törlődés– értékadás (állapot változtatás)• Megengedett konstrukciók– szekvencia– elágazás– ciklus• Bizonyítható, hogy a fenti szabályok megtartásával minden algoritmussal megoldható feladatra adhatómegoldás
Strukturált programozás esetén a program alapvetően programblokkokból áll ( lásd majd: eljárások).
- A Strukturális programozás logikája nem engedi meg a GOTO utasítást: a programban egy adott utasítástól elugrani egy tetszőleges másik utasításhoz és onnan folytatni a végrehajtást.
Bár a programozási nyelvek ezt megengedik:Pl.:
cimke1: utasítás1 utasítás2………..…………GOTO cimke1
A Strukturális programozás csak ezeket a lehetőségeket engedi meg: szekvencia, elágazás, ciklus
Miért?Mert így a program áttekinthetőbb, strukturáltabb, könnyebb belőle építkezni, jobban szervezhető, modularizálható, egységekre szervezhető.
A GOTO-val egy nagyobb program átláthatatlanabb lesz és nem lehet strukturálni, modulokat, eljárásokat szervezni belőle.
Ezért a Folyamatábra nem jó eszköz a strukturált programozás szempontjából, mert megengedi, hogy ugrálni tudjak bármelyik két pont között. (GOTO)
A Struktogram viszont csak a strukturált programozás lehetőségeit engedi meg: szekvencia, elágazás, ciklus
A csak szekvenciákból, szelekciókból és iterációkból építkező programot strukturált programnak nevezzük. A strukturált programozásban nem megengedett a feltétel nélküli ugrás, így többek között a ciklusból sem ugorhatunk ki. Ebből az is következik, hogy a program minden vezérlő szerkezetének (szekvencia, szelekció, iteráció) - és magának a teljes programnak is - egyetlen belépési és egyetlen kilépési pontja van, így a program lényegesen áttekinthetőbb. A strukturált programozás általános módszereit E. W. Dijkstra dolgozta ki.
http://hu.wikipedia.org/wiki/ Strukturált _ programozás
Összefoglalva azt a programozási módszert, amikor a nagy problémát kisebb részfeladatok halmazára bontunk, és a megoldást a részfeladatok megoldásával kezdjük. A megvalósítandó programot modell sorozattal közelítjük meg. A strukturált programozás fontos alapelve a lépésenkénti finomítás elve, melynek a lényege, hogy a megoldandó feladatot részfeladatokra bontjuk úgy, hogy önmagukban
19
megoldhatók legyenek. Az összes részfeladat megoldása után, az eredeti feladat megoldása a megfelelő illesztésekre korlátozódik.
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:- Beolvas egy egész számot. Írja ki, hogy prímszám vagy nem- Két szám legkisebb közös többszöröse.- Két szám legnagyobb közös osztója - Beolvas egy 4 jegyű egészet , majd a számjegyeket kiírja egymás alá.- Olvasson be 4 számjegyet. Állítson össze egy egész tipusú számot a 4 szájegyből.
Írassa ki a számot.- Írassuk ki 3 oszlopban: 1. oszlop: szögek 0-180 fokig 10-esével, 2.oszlop: szinusz, 3. oszlop: tangens
10 karakter széles oszlopok, 3 tizedes jegyen a valósok. tangens 90 foknál értelmetlen.
20
2. Tömbök 2/1.példaTömbök: alap feltöltés, kiíratás.
static void Main() { int[] tomb1; // deklarálás tomb1 = new int[10]; // helyfoglalás a memóriában // vagy a két utasítás összevonható: int[] tomb1 = new int[5]; // 10 elemű tömb: 0..9-ig indexel tomb1[0] = 8; // C-ben a tömb első eleme a 0. indexű
int[] tm1 = new int[3] {3,4,5};string[] stm1 = new string[3] {"első","második","harmadik"};
Console.WriteLine("A tömb 0.indexű eleme= "+tomb1[0]); int i; for (i = 0; i < 10; i++) tomb1[i] = i*i; Console.WriteLine("A 10 elemű tömb elemei: "); for (i = 0; i <10; i++) Console.WriteLine(tomb1[i]); Console.ReadLine(); }
2/2.példaTöltsön fel egy 10 elemű tömböt a billentyűzetről. Majd írassa ki a tömb elemeit egymás mellé space-val elválasztva, majd egymás alá is.static void Main() { int[] tomb1=new int[10]; Console.WriteLine("10 elemű tömb feltöltése billentyűzetről.\nAdja meg a 10 egész számot!"); int i; for (i = 0; i <10; i++) { Console.Write(i + "-ik elem= "); tomb1[i] = Convert.ToInt32(Console.ReadLine()); } Console.WriteLine("A tömb elemei egymás mellett:"); for (i = 0; i < 10; i++) Console.Write(tomb1[i] + " "); Console.WriteLine("\nA tömb elemei egymás alatt:"); for (i = 0; i < 10; i++) Console.WriteLine(tomb1[i]); Console.ReadLine(); }
2/3.példaTöltsünk fel egy 10 elemű tömböt 50 és 80 közötti véletlen számokkal, majd írassuk ki a tömb elemeit egymás mellé space-ekkel elválsztva.
static void Main() {
21
int[] tomb1=new int[10]; Console.WriteLine("10 elemű tömb feltöltése 50 és 80 közötti véletlen számokkal"); int i; Random veletlen1 = new Random(); // Random: egy osztály, veletlen1: egy példány belőle (lehet több is) for (i = 0; i < 10; i++) tomb1[i] = veletlen1.Next(50, 80); // 50 még benne van, 80 már nincs Console.WriteLine("A tömb elemei egymás mellett:"); for (i = 0; i < 10; i++) Console.Write(tomb1[i] + " "); Console.ReadLine(); }
2/3/B példaA tömb mérete futási időben is megadható
static void Main() { Console.Write("Mekkora legyen a tömb mérete?\nn="); int n = Convert.ToInt32(Console.ReadLine()); int[] tomb = new int[n]; int i; for (i = 0; i < n; i++) tomb[i] = i; Console.WriteLine("A tömb elemeinek száma: "+tomb.Length); Console.ReadLine(); }
2/4.példa10 elemű egészekből álló tömbTöltse fel a tömböt 25-től a páratlan számokkal.A feltöltés után írassa ki a tömb elemeit egymás mellé szóközzel elválasztva.Majd írassa ki az elemeket fordított sorrendben.
static void Main() { int[] tomb1=new int[10]; Console.WriteLine("10 elemű tömb feltöltése 25-től a páratlasn számokkal számokkal"); int i; for (i = 0; i < 10; i++) tomb1[i] = 25 + i * 2; Console.WriteLine("\nA tömb elemei egymás mellett:"); for (i = 0; i < 10; i++) Console.Write(tomb1[i] + " "); Console.WriteLine("\nA tömb elemei fordított sorrendben:"); for (i = 9; i >=0; i--) Console.Write(tomb1[i] + " "); Console.ReadLine(); }
2/5.példa1000 elemű egészekből álló tömb. Töltse fel a tömböt 70 és 90 közötti véletlen egészekkel.Majd számolja ki az elemek összegét és átlagát és írassa ki azokat.
22
static void Main() { int[] tomb1=new int[1000]; int osszeg=0; Console.WriteLine("1000 elemű tömb feltöltése 70 és 90 közötti véletlen számokkal:"); int i; Random veletlen1 = new Random(); for (i = 0; i < 1000; i++) tomb1[i] = veletlen1.Next(70, 90); for (i = 0; i < 1000; i++) osszeg = osszeg + tomb1[i]; Console.WriteLine("a tömb elemeinek összege= " + osszeg + "\nés átlaga= " + (double)osszeg / 1000); Console.ReadLine(); }
2/6.példa10 elemű egészekből álló tömb. Töltsük fel a tömböt 1-től a négyzetszámokkal.Írassuk ki egymás mellé az elemeket szóközzel elválasztva.Forgassa el a tömb elemeit jobbra, úgy hogy az utolsó az első helyre kerüljön.Újra írassa ki az elemeket egy sorba egymás mellé szóközzel elválasztva.
static void Main() { int[] tomb1 = new int[10]; int i; for (i = 0; i < 10; i++) tomb1[i] =(i+1)*(i+1); Console.WriteLine("A tömb elemei:"); for (i = 0; i < 10; i++) Console.Write(tomb1[i] + " "); int cs; cs = tomb1[9]; for (i = 8; i >= 0; i--) tomb1[i + 1] = tomb1[i]; tomb1[0] = cs; Console.WriteLine("\nA tömb elemei jobbra forgatva:"); for (i = 0; i < 10; i++) Console.Write(tomb1[i] + " "); Console.ReadLine(); }
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:10 elemű egészekből álló tömb. Töltsük fel a tömböt 1-től a négyzetszámokkal.Írassuk ki egymás mellé az elemeket szóközzel elválasztva.Tükrözze az elemeket a középvonalra. ( Fordított sorrendbe rendeződnek az elemek. )Újra írassa ki az elemeket egy sorba egymás mellé szóközzel elválasztva.
2/7.példaA: maximum 100 elemű egészekből álló tömb. Olvassuk be hogy hány elemet fogunk kezelni (n).
23
Olvassuk be a tömbbe az elemeket. Írassuk ki az elemeket a tömbindexükkel együtt 2 oszlopban.
static void Main() { int[] tomb1 = new int[100]; int i,n; Console.Write("Adja meg hány elemet töltsünk fel a tömbben.\nn= "); n = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("Adja meg az elemeket!"); for (i = 0; i < n; i++) { Console.Write(i + "-edik elem= "); tomb1[i] = Convert.ToInt32(Console.ReadLine()); } Console.WriteLine("A beolvasott elemek:"); for (i = 0; i < n; i++) Console.WriteLine(i+": "+tomb1[i]); Console.ReadLine(); }
b, eset: mint az előző, de beolvasás után írassuk ki a beolvasott számok összegét és átlagát.
2/8.példa10x15-es (2 dimenziós) egészekből álló tömb.Töltse fel az elemeket 1-500 közötti véletlen számokkal.Majd írassa ki a tömb elemeit, 10 sorban, 15 oszlopban. Az egyes oszlopok 4 karakter szélesek legyenek.Majd számítsa ki az elemek átlagát. Írassa ki az átlagot és azokat az elemeket, amelyek nagyobbak az átlagnál.
static void Main() { int[,] tomb1 = new int[10,15]; int i,j; Random veletlen1 = new Random(); for(i=0;i<10;i++) for (j = 0; j < 15; j++) tomb1[i, j] = veletlen1.Next(1, 500); Console.WriteLine("A 10x15-ös tömb elemei:"); for (i = 0; i < 10; i++) { for (j = 0; j < 15; j++) Console.Write("{0,4}", tomb1[i, j]); Console.WriteLine(); } double atlag = 0; for (i = 0; i < 10; i++) for (j = 0; j < 15; j++) atlag = atlag + tomb1[i, j]; atlag = atlag / 150; Console.WriteLine("A tömb elemeinek átlaga= " + atlag); Console.WriteLine("Az átlagnál nagyobbak= "); for (i = 0; i < 10; i++)
24
for (j = 0; j < 15; j++) if (tomb1[i, j] > atlag) Console.Write(tomb1[i, j] + " "); Console.ReadLine(); }
2/9.példa10x10-es (2 dimenziós) egészekből álló tömb.Töltse fel az elemeket: 1. sor: 1-től 10, 2. sor:11-20…egészen 100-igMajd írassa ki a tömb elemeit, 10 sorban, 10 oszlopban. Az egyes oszlopok 3 karakter szélesek legyenek.Tükrözze a tömböt a függőleges felező vonalára.Így is írassa ki a tömböt.
static void Main() { int[,] tomb1 = new int[10, 10]; int i, j; for (i = 0; i < 10; i++) for (j = 0; j < 10; j++) tomb1[i, j] = i*10+j+1; Console.WriteLine("A 10x10-es tömb elemei:"); for (i = 0; i < 10; i++) { for (j = 0; j < 10; j++) Console.Write("{0,3}", tomb1[i, j]); Console.WriteLine(); } Console.ReadLine(); int cs; for (i = 0; i < 10; i++) for (j = 0; j < 5; j++) { cs = tomb1[i,j]; tomb1[i,j] = tomb1[i,9 - j]; tomb1[i,9 - j] = cs; } Console.WriteLine("A 10x10-es tükrözött tömb elemei:"); for (i = 0; i < 10; i++) { for (j = 0; j < 10; j++) Console.Write("{0,3}", tomb1[i, j]); Console.WriteLine(); } Console.ReadLine(); }
25
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:10x10-es (2 dimenziós) egészekből álló tömb.Töltse fel az elemeket: 1. sor: 1-től 10, 2. sor:11-20…egészen 100-igMajd írassa ki a tömb elemeit, 10 sorban, 10 oszlopban. Az egyes oszlopok 3 karakter szélesek legyenek.Tükrözze a tömböt a csökkenő átlójára.Így is írassa ki a tömböt.
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:Olvasson be maximum 100 db egész számot. A beolvasás végét 0 jelezze.Írassa ki az elemeket a beolvasás sorrendjében.
2/10. PéldaTömb elemeinek rendezése. Később majd tanulunk több fajta rendezési algoritmust.Olvasson be 5 egész számot. rendezze a számokat növekvő sorrendbe. Írja ki a rendezett tömb elemeit.static void Main(){
int[] tomb1 = new int[5]; Console.WriteLine("5 elemű tömb feltöltése billentyűzetről.\nAdja meg az 5 egész számot!"); int i; for (i = 0; i <=4; i++) { Console.Write(i + "-ik elem= "); tomb1[i] = Convert.ToInt32(Console.ReadLine()); } int j, csere; for (j = 0; j <= 4; j++) for (i = 0; i <= 3; i++) if(tomb1[i]>tomb1[i+1]) { csere = tomb1[i]; tomb1[i] = tomb1[i+1]; tomb1[i+1] = csere; } Console.WriteLine("\nA rendezett tömb elemei :"); for (i = 0; i <=4; i++) Console.WriteLine(tomb1[i]); Console.ReadLine();}
Buborék rendezés: a tömbön végig megy az utolsó előtti elemig for (i = 0; i <= 3; i++) Ha az adott elem nagyobb mint a következő, akkor megcseréli őket egy harmadik változón keresztül. (csere): csere = tomb1[i]; tomb1[i] = tomb1[i+1]; tomb1[i+1] = csere;
Ha ezt a folyamatot 5-ször megcsinálja for (j = 0; j <= 4; j++)akkor rendezett lesz a tömb.
26
2/11 foreach használataAz utasítás formája: foreach (azonosító in vektor) utasítás;
Ez az utasítás egyenértékű a vektor-elemeken történő végiglépegetéssel. Azazonosító, mint ciklusváltozó felveszi egyenként e vektor elemeit.
Előnyei:- Nem kell tudni hozzá a tömb méretét ( nem kell a mérettel foglalkozni.)- Nem kell foglalkozni a tömb elemeinek az elérésénél a tömbindexel.
Hiszen a foreach végig megy minden elemen.
Töltsünk fel egy tömböt. Majd írassa ki a tömb elemeit a foreach segítségével.
static void Main(){ int[] tomb = new int [] {0,1,2,5,7,8,11}; Console.WriteLine("A tömb elemei:"); foreach (int i in tomb)
// A foreach-on kívül másik i változó-deklarálás és használat nem lehet. /*
Így nem jó:int i;foreach (i in tomb)
*/ Console.Write(i+" ");
// Console.WriteLine(i); Itt hibát jelezne, mert az i változót nem látja csak a foreach-en belül. Console.ReadLine();}
Erre kiírja: 0 1 2 5 7 8 11Vagyis: A foreach (int i in tomb) –ben
az i nem a ciklusváltozó, hanem a tömb egy elemének az értéke.
27
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:Feladat foreach-el:Töltsön fel egy 20 elemű tömböt 25-től a négyzetszámokkal. Írassa ki az elemeket egymás mellé szóközzel elválasztva. Majd írassa ki az 5-el osztható elemeket.
28
3. Néhány kiegészítő példa
Kilépés az alkalmazásból:System.Environment.Exit(1);1: Kilépéskor ezt a kódot adja át az operációs rendszernek.
Hanggenerálás:Console.Beep(400,1000);400Hz-es hangot ad 1mp ig
Ugrás adott pozícióhoz:Console.SetCursorPosition(oszlop,sor);oszlop-sorhoz ugrik.
3/1. PéldaPiros csillagokat ír ki 1 mp-enként billentyűleütésig, véletlen helyen a képernyőn
static void Main(){ Random veletlen1 = new Random(); Console.ForegroundColor = ConsoleColor.Red; do { Console.SetCursorPosition(veletlen1.Next(1, 80), veletlen1.Next(1, 25)); Console.Write("*"); System.Threading.Thread.Sleep(1000);
// using System.Threading után már csak Thread.Sleep(1000); kellene } while (Console.KeyAvailable == false);}
Házi FeladatRajzoljunk ki *-okból egy téglalapot: 10 sor 20 oszlop.Bal felső sarok: 5. sor, 15. oszlop
29
Mentésről:Új Project létrehozásakor a forráskódot a Program.cs fájlba teszi. Ezt ki is írja a kódszerkesztő ablak címsorába.File menü/ Save program.cs as… pl. c:\ide könyvtárba / Objektumnév: Proba, fájl típusa C# file (*.cs)Ilyenkor elmenti a Proba.cs fájlt. ( Csak 1 fájl ! )Erre megváltozik az ablak címsora is: Proba.cs-re.Visszatöltés:File menü /Open file ( és nem Open Project )Egy megnyitott Projectbe kell betölteni a fájlt, ahhoz, hogy futtatható legyen.
Logikai ( bool ) tipus.
3/3. Példastatic void Main(){
bool a=true; Console.WriteLine(a); -> Kiírja: True}
3/4. Példastatic void Main(){ bool a=true; int b = 5; a = b > 7; Console.WriteLine(a); -> Kiírja: False}
/* Az a=b>7; helyett állhat: if (b > 7) a = true;
else a = false; */
Konstans megadása:
static void Main(){ const int a = 15; Console.WriteLine(2 * a);}
Több irányú elágazás
3/5. PéldaOlvasson be egy számot 1-7-ig. Majd írja ki: ha 1: hétfő…Ha nem 1-7 közötti, akkor ezt jelezze.
static void Main(){ int a; Console.WriteLine("Adj meg egy 1-7 közötti egészet"); a = Convert.ToInt32(Console.ReadLine()); string s; switch (a)
30
{ case 1: s = "hétfő"; break; case 2: s = "kedd"; break; case 3: s = "szerda"; break; case 4: s = "csütörtök"; break; case 5: s = "péntek"; break; case 6: s = "szombat"; break; case 7: s = "vasárnap"; break; default: s="A szám nem 1-7 közötti egész."; break; // minden elágazást valamilyen vezérlésátadással // kell befelyezni: break, goto return... } Console.WriteLine(s); Console.ReadLine();}
3/6. PéldaOlvasson be egy 10 és 20 közötti egészet. ( 10 és 20 még bele tartozik. ) Addig olvassa be a számokat, amíg nem lesz 10-20 közötti. A végén írassa ki a szám kétszeresét.
static void Main(){ int a, b, c,d; Console.WriteLine("Adj meg egy 10-20 közötti egészet"); a = Convert.ToInt32(Console.ReadLine()); while(!(a>=10 && a<=20)) { Console.WriteLine("A szám nem 10-20 közötti, add meg újra."); a = Convert.ToInt32(Console.ReadLine()); } Console.WriteLine("a beolvasott szám kétszerese="+2*a); Console.ReadLine();}
3/6/B. PéldaOlvasson be egy számot. Addig olvassa be az adatot, amíg nem számot ad meg. A végén írassa ki a szám kétszeresét.
double x; Console.WriteLine("Adj meg egy számot"); string s=Console.ReadLine(); while (!double.TryParse(s, out x))
// Megpróbálja átalakítani. s => x// Ha sikerül, akkor a függvény értéke igaz, egyébként hamis// van int. double.TryParse is
{ Console.WriteLine("Nem szám! Próbálkozz újra"); s = Console.ReadLine(); } Console.WriteLine("A szám kétszerese: "+2 * x); Console.ReadLine();
31
3/6/C. PéldaHázi feladat: Hasonló az előző példához. Olvasson be egy egész számot. Addig olvassa be az adatot, amíg nem egészet ad meg. A végén írassa ki a szám kétszeresét.Megoldás: int. double.TryParse metódussal
3/7 PéldaTegyünk egy * karaktert a 15. sor 40. oszlopába.A csillagot a bal és a jobb nyilakkal mozgassuk.A program akkor érjen véget, ha nem a jobbra vagy a balra mutató nyilat nyomjuk le.
static void Main() { int sor=15, oszlop=40; Console.SetCursorPosition(oszlop,sor); Console.Write("*"); oszlop++; ConsoleKeyInfo cki; // A Console.ReadKey() utasítás ConsoleKeyInfo típusú adatot ad. cki = Console.ReadKey(); while (cki.Key == ConsoleKey.RightArrow || cki.Key == ConsoleKey.LeftArrow) { if (cki.Key == ConsoleKey.LeftArrow) { //Visszalép 2-őt. Kitesz egy csillagot és letörli az előzőt. oszlop=oszlop-2; Console.SetCursorPosition(oszlop, sor); Console.Write("* "); // Visszaugrik a kiírt * mellé oszlop++; Console.SetCursorPosition(oszlop, sor); } if (cki.Key == ConsoleKey.RightArrow) { //Visszalép 1-el, letörli a csillagot és kirak mellé egyet. oszlop--; Console.SetCursorPosition(oszlop, sor); Console.Write(" *"); oszlop = oszlop + 2; } cki = Console.ReadKey(); } }
3/7/B PéldaHázi feladat1. Kezeljük le, azt, hogy mi történjen, ha elérjük a képernyő szélét.2. Kezeljük le a fel és a lefelé mutató nyilakat is.
32
3/8 PéldaÍrassuk ki a rendszeridőt 1 mp-enként a bal felső sarokba.
static void Main() { DateTime d; do { d = DateTime.Now; string s = Convert.ToString(d.Hour) + ":" + Convert.ToString(d.Minute) + ":" + Convert.ToString(d.Second) +" "; // A végére kell néhány space, mert van amelyik szám 1, van amelyik 2 karakteres. Console.WriteLine(s); System.Threading.Thread.Sleep(1000); Console.SetCursorPosition(0,0); } while (Console.KeyAvailable == false); Console.ReadLine(); }
Console.WriteLine(d); //Így az idő elé a dátumot is kiírná
3/9 PéldaFuttatható fájl paraméterezése.Készítsünk egy exe fájlt. proba.exepl. DOS ablakban:Az exe fájlt futtassuk 2 paraméterrel: 2 egész számmal:proba 10 15
A program írja ki a két szám összegét.
static void Main(string[] args) { Console.WriteLine(Convert.ToInt32(args[0]) + Convert.ToInt32(args[1])); Console.ReadLine(); }
Az összes argumentumot így is elérhetjük:
foreach (string arg in args) {Console.WriteLine("Arg: {0}", arg);
33
3/10 PéldaEgyszerű Menü vezérelt program
Vegye fel az a változót. (a=100)Ciklusban hajtsa végre:
- Írassa ki a változó értékét.- Írassa ki alá a menüt:
H: Hozzáad 10-etL: Levon 5-ötV: Vége
Válasszon a menüből!Amíg a V betűt nem nyomjuk le (V=Vége)
- Nagy és kisbetűs változatot is fogadja el.- Egyéb karakterre ne csináljon semmit: folytassa a ciklust.
Ezt az egyszerű esetet is menü-vezérlésnek hívják.Igazi menüket is fogunk majd készíteni az Objektumorientált programozás gyakorlat tantárgyban.
static void Main(string[] args) { int a = 100; char valasz; do { Console.Clear(); Console.WriteLine("\n\n"); Console.WriteLine("A változó értéke= " + a+"\n"); Console.WriteLine("H: Hozzáad 10-et."); Console.WriteLine("L: Levon 5-öt"); Console.WriteLine("V: Vége"); Console.WriteLine("\nVálasszon a menüből!"); valasz = char.ToUpper(Convert.ToChar(Console.Read()));
Console.WriteLine(); // Kitörli a Read() után a Bufferben maradt felesleges karaktereket.// pl. Enter hatása
switch (valasz) { case 'H': a = a + 10; break; case 'L': a = a -5; break; } } while(valasz != 'V'); }
34
4. Karakter típus
Char tipus
static void Main(){ char c = 'x';
// char típusnál 1-es aposztróf kell, a stringnél 2-es Console.WriteLine(c);}
4/1. PéldaÍrassuk ki 3 sorba:1. sor abc kis betűi egymás mellé szóközzel elválasztva.2. sor ABC nagybetűi3. sor számjegyek 0-tól 9-ig.
static void Main(){ char c; for(c='a';c<='z';c++) Console.Write(c+" "); Console.WriteLine(); for (c = 'A'; c <= 'Z'; c++) Console.Write(c + " "); Console.WriteLine(); for (c = '0'; c <= '9'; c++) Console.Write(c + " "); Console.WriteLine();}
4/2. PéldaÍrassa ki a gép karakterkészletének első 500 elemét.A karakter ábrázolásra 2 byte kódot használ 0..65535Ebből a lényeg a 0..500-on megtalálható.
static void Main(){ int a; Console.Clear(); for (a = 0; a <500; a++) Console.Write(Convert.ToChar(a) + " ");
Console.ReadLine(); }megfigyelés: a kisbetűk, nagybetűk, számjegyek egymás után jönnek.
4/3. PéldaÍrassa ki a köv. karakterek kódját: A,Z,a,z,0,9lesz: A: 65, Z:90, a:97, z:122, 0: 48, 9: 57
static void Main(){ Console.WriteLine("A: " + Convert.ToInt32('A'));
35
Console.WriteLine("Z: " + Convert.ToInt32('Z')); Console.WriteLine("a: " + Convert.ToInt32('a')); Console.WriteLine("z: " + Convert.ToInt32('z')); Console.WriteLine("0: " + Convert.ToInt32('0')); Console.WriteLine("9: " + Convert.ToInt32('9')); Console.ReadLine();}
4/4. PéldaOlvasson be egy karaktert. Írja vissza a karaktert a képernyőre.Írja ki hogy betű, szám vagy egyéb karakter.
static void Main(){ char a; Console.WriteLine("Adj meg 1 karaktert."); a = Convert.ToChar(Console.ReadLine()); Console.WriteLine("A beolvasott karakter: "+a); if(( a>='A' && a<='Z') || ( a>='a' && a<='z') ) Console.WriteLine("betű érkezett."); else if (a >= '0' && a <= '9') Console.WriteLine("szám érkezett."); else Console.WriteLine("egyéb karakter érkezett."); Console.ReadLine();}
4/5. PéldaOlvasson be egy karaktert. Írja ki az előtte levő és az utána levő karaktert a képernyőre.
static void Main(){ char a; Console.WriteLine("Adj meg 1 karaktert."); a = Convert.ToChar(Console.ReadLine()); Console.WriteLine("Az előtte lévő karakter: "+Convert.ToChar(Convert.ToInt32(a)-1));
// így is jó: Console.WriteLine("Az előtte lévő karakter: " + Convert.ToChar(a - 1)); Console.WriteLine("Az utána lévő karakter: " + Convert.ToChar(Convert.ToInt32(a) + 1)); Console.ReadLine();}
4/6. PéldaÍrassa ki 2 oszlopban: 1. oszlop: nagybetűk A-Z, 2. oszlop: a karakter ASCII kódja.Mindkét oszlop 5 karakter széles legyen.static void Main(){ char a; for(a='A';a<='Z';a++) Console.WriteLine("{0,5}{1,5}",a,Convert.ToInt32(a)); Console.ReadLine();}
4/7. PéldaOlvasson be 4 számjegy karaktert. Állítson össze egy egész tipusú számot a 4 szájegyből.
36
Írassa ki a számot.
static void Main(){ char a,b,c,d; int szam; Console.WriteLine("Adjon meg 4 db számjegy karaktert."); a = Convert.ToChar(Console.ReadLine()); b = Convert.ToChar(Console.ReadLine()); c = Convert.ToChar(Console.ReadLine()); d = Convert.ToChar(Console.ReadLine()); szam = (a - 48) * 1000; szam = szam + (b - 48) * 100; szam = szam + (c - 48) * 10; szam = szam + d - 48;
Console.WriteLine(szam); Console.ReadLine();}
37
5. Karakterláncok ( Stringek )
A c#-ban 2 fő típus van a stringekre: string, StringBuilder;
A string-et használjuk és nem a stringBuildert, mert egyszerűbb.
Olvasmány:
Néhány megjegyzés a string és a stringBuilder témában:A string függvények nem módosítják az eredeti szöveget, (Ez a .NET tulajdonsága. A Java-hoz
hasonlóan ) Ha magát a szövegobjektumot is módosítani akarom, például az adott szöveg egy karakterét kicserélni egy másikra, akkor például a StringBuilder osztályt érdemes használni.
A string típus C#-ban a Javához hasonlóan konstans abban az értelemben, hogy nem lehet megváltoztatnia tartalmát a létrehozás után. Az összes stringmanipuláló függvény egy új stringet ad vissza. … Létezik megváltoztatható tartalmú string is C#-ban, ez a StringBuilder.
Mi a különbség a System.String és a System.StringBuilder osztály között?- A System.String állandó, míg a System.StringBuilder arra lette tervezve, hogy legyen egy változó sztring, amin sokféle operandus végrehajtása lehetséges.
Pl. string s = "Hello";s[1] = "*"; ezt nem engedi. ( s[1] = '*'; ez sem jó )
Hiba: a string nem módosítható
A Replace-vel meg az a baj, hogy egy karakter minden előfordulását cseréli.Remove + Insert jó
A StringBuilder másik tulajdonsága: módosítható a hossza a programon belül.- hatékonyabb, gyorsabb a feldolgozása.
StringBuilder is more efficient in the cases, where a lot of manipulation is done to the text. Strings are immutable, so each time it is being operated on, a new instance is created.
Például:A következő példa 9999 db stringet hoz létre:
string s = "";for(int i = 0; i<10000; i++){ s = s + i.ToString();}
De persze csak 1 stringet akartuk létrehozni.StringBuilderrel ehhez hasonló 1 szöveget hoz csak létre.
for(int i=0; i<100000; i++){
s.Append(i.ToString());}
38
Van, ami viszont a string-ben benne van, de nincs a StringBuilder-ben.A StringBuilder egy hiányossága a string-hez képest:
- nincs benne olyan függvény, ami részszöveget keres a szövegben. mint a string-nél az IndexOf.Ennek megoldása: 'A'-t keresi s-benint a;a = s.ToString().IndexOf('A');
5/1. PéldaOlvasson be egy karakterláncot.Írassa ki a szöveget, a hosszát, fordítva, a szóközök számát
static void Main(){ string s ; Console.WriteLine("Adj meg egy szöveget!"); s=Console.ReadLine(); Console.WriteLine("A beolvasott szöveg:\n" + s); Console.WriteLine("A szöveg hossza:\n" + s.Length); Console.WriteLine("A szöveg fordítva:"); int a; for (a = s.Length - 1; a >= 0; a--) Console.Write(s[a]); Console.WriteLine(); int db = 0; for (a = 0; a < s.Length; a++) if (s[a] == ' ') // Ide 1-es aposztróf kell (Char), a 2-es aposztrófot nem fogadja el. // Az s szöveg i. eleme, vagyis az aktuális indexelt elem karakter típus, mivel karakterek // sorozatából épül fel, vagyis az s[i], a szöveg egy eleme karakter. db++; Console.WriteLine("A szóközök száma= " + db); Console.ReadLine();}
5/2. PéldaOlvasson be egy karakterláncot. Az első A betűtől kezdve írassa ki 10 karakterét.Tegye a végéhez hogy ‘Szia’. Írassa így is ki.
static void Main(){ string s; Console.WriteLine("Adj meg egy szöveget!"); s=Console.ReadLine(); int a, i; a = s.IndexOf('A'); // ha nem találja, akkor -1 az értéke if (a >= 0) for (i = a; i < Math.Min(a + 10, s.Length); i++) Console.Write(s[i]); s = s + "Szia"; Console.WriteLine("\n" + s); Console.ReadLine();
39
}
5/3. PéldaOlvasson be egy karakterláncot. Vegye ki belőle a 4. karaktertől kezdődően 2 karaktert.Írassa ki az új szöveget.
static void Main(){ Console.WriteLine("Adj meg egy szöveget!"); string s; s=Console.ReadLine(); s=s.Remove(3, 2);
// Az s.Remove(3, 2); még nem változtatja meg s-et, csak előállít egy stringet, // mint egy függvény.
Console.WriteLine(s); Console.ReadLine();}
5/4. PéldaOlvasson be egy szöveget. A 3. karaktert cserélje ki benne ’*’-ra;static void Main(){ string s; Console.WriteLine("Adj meg egy szöveget!"); s=Console.ReadLine(); s = s.Remove(2, 1); s = s.Insert(2,"*"); Console.WriteLine(s); Console.ReadLine();}
5/5. PéldaOlvasson be egy szöveget.Az első ’xx’-et ’YYY’-ra
static void Main(){ string s; Console.WriteLine("Adj meg egy szöveget!"); s=Console.ReadLine(); int i; i = s.IndexOf("xx"); if (i >= 0) { s = s.Remove(i, 2); s = s.Insert(i, "YYY"); } Console.WriteLine(s); Console.ReadLine();}
5/6. Példa Olvasson be egy karakterláncot. Vegye ki belőle a szóközöket. Írassa ki így a karakterláncot.static void Main()
40
{ string s,s2; Console.WriteLine("Adj meg egy szöveget!"); s=Console.ReadLine(); int i; s2 = ""; for (i = 0; i < s.Length; i++) if (s[i] != ' ') s2 = s2 + s[i]; s = s2; Console.WriteLine(s); Console.ReadLine();}
b, megoldás:
static void Main(){ string s; Console.WriteLine("Adj meg egy szöveget!"); s=Console.ReadLine(); while (s.IndexOf(' ') >= 0) s=s.Remove(s.IndexOf(' '), 1); Console.WriteLine(s); Console.ReadLine();}
Ez nem jó, mert a többszörös szóözöknek csak a felét veszi ki:A ciklus közben a Remove-nál változik a fájl hossza.
static void Main() { string s, s2; Console.WriteLine("Adj meg egy szöveget!"); s = Console.ReadLine(); int i; s2 = ""; for (i = 0; i < s.Length; i++) if (s[i] == ' ') s=s.Remove(i, 1); Console.WriteLine(s); Console.ReadLine(); }
5/7 PéldaOlvasson be egy szöveget. Minden ’xx’-et ’YYY’-ra cseréljen ki.static void Main(){ string s; Console.WriteLine("Adj meg egy szöveget!"); s=Console.ReadLine(); int i; while ((i = s.IndexOf("xx")) >= 0) {
41
s = s.Remove(i, 2); s = s.Insert(i, "YYY"); } Console.WriteLine(s); Console.ReadLine();}
5/8. PéldaOlvasson be egy karakterláncot. Minden szóközt cseréljen ki benne *-ra.
static void Main(){ string s,s2; Console.WriteLine("Adj meg egy szöveget!"); s=Console.ReadLine(); int i; s2 = ""; for (i = 0; i < s.Length; i++) if (s[i] == ' ') s2 = s2 + '*'; else s2 = s2 + s[i]; s = s2; Console.WriteLine(s); Console.ReadLine();}
Házi feladat b, megoldás: Az előző példához hasonlóan while-al.
C, for ciklus+Remove+Insert
static void Main() { string s, s2; Console.WriteLine("Adj meg egy szöveget!"); s = Console.ReadLine(); int i; s2 = ""; for (i = 0; i < s.Length; i++) if (s[i] == ' ') { s = s.Remove(i, 1); s = s.Insert(i, "*"); } Console.WriteLine(s); Console.ReadLine(); }
d, megoldás:C#-nak van egy beépített függvénye,ami ezt 1 lépésben megcsinálja:
………… s=s.Replace(' ', '*');
42
// Minden helyen kicseréli a szövegben. Console.WriteLine(s);…………
5/9. PéldaKészítsen egy karakterláncot az ABC nagy betűiből. Írassa ki azt.
static void Main(){ string s; char c; s = ""; for (c = 'A'; c <= 'Z'; c++) s = s + c; Console.WriteLine(s); Console.ReadLine();}
5/10. PéldaOlvasson be egy maximum 80 karakter hosszú karakterláncot. Írassa ki a szöveget jobbra a képernyőre. ( pl. 1 sor 80 karakter )
static void Main(){ string s; Console.WriteLine("Adj meg egy szöveget!"); s = Console.ReadLine(); int i; for (i = 0; i < Console.BufferWidth - s.Length; i++) Console.Write(' '); Console.WriteLine(s); Console.ReadLine();}
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:- Olvasson be egy karakterláncot. Írassa ki az első és a második ‘A’ betű közötti szöveget a képernyőre.- Olvasson be egy 4 karakteres karakterláncot, ami egy 4 jegyű egész számot tartalmaz.
Írja ki a képernyőre a szám kétszeresét. A beolvasott számot számjegyenként dolgozza fel.Számjegyenként kell feldolgozni, mert Convert.ToInt32(s) egy lépésben átváltaná egésszé.A Karakter típusnál volt hasonló példa.
5/11 PéldaOlvasson be egy karakterláncot. A szöveg tartalmazzon egész számokat, szóközökkel elválasztva. Lehet többszörös szóköz is.Írassa ki a számokat egymás alá. A végén írassa ki az számok összegét.( Azoknál a feladatoknál, amelyeknél adatokat kell fájlból beolvasni, a feladat gyakran azzal kezdődik, hogy szövegfájlból kell számokat beolvasni, ahol 1 sorban több számjegy szerepel.)
Az s.split-el lehet pl. szóközök mentén darabolni a stringet:
---------------------------
43
string[] words = s.Split(' ');foreach (string word in words){ Console.WriteLine(word);}
--------------------------
static void Main() { string s, s2; Console.WriteLine("Adj meg számokat szóközökkel elválasztva"); s = Console.ReadLine(); string[] szamok = s.Split(' '); int osszeg = 0; foreach (string szam in szamok) if(szam!="") // többszörös szóközök esetén üres sztringet tesz a szamok tömbbe. { Console.WriteLine(szam); osszeg += Convert.ToInt32(szam); } Console.WriteLine(osszeg); Console.ReadLine(); }
5/12. PéldaOlvasson be egy dátumot ÉÉÉÉ-HH-NN formában. Alakítsa át NN-HH-ÉÉÉÉ formára és írja vissza a képernyőre.
static void Main(){ string s,s2; Console.WriteLine("Adj meg egy dátumot ÉÉÉÉ-HH-NN formában"); s = Console.ReadLine(); s2=s.Substring(8,2)+"-"+s.Substring(5,2)+"-"+s.Substring(0,4); s=s2; Console.WriteLine("A dátum NN-HH-ÉÉÉÉ formában= "+s); Console.ReadLine();}
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:- Olvasson be egy karakterláncot.
Egy másik sztringbe készítse el a beolvasott sztring fordítottját. Írassa ki az eredményt.- Olvasson be egy szöveget. döntse el, hogy tükörszöveg e. És írja ki, hogy tüköszöveg e.
Egyéb fontos függvények a Stringekkel kapcsolatban:s.-ot beírva kiválaszthatóak.
44
6. Metódusok, Eljárások, függvények
OOP-ben az eljárásokat, függvényeket Metódusoknak hívjuk.
Eljárások 1. Eljárásokat akkor írunk, ha: - egy részfeladatot többször akarunk végrehajtani, vagy
- egy nagyobb feladatot részekre szétbontva áttekinthetőbbé akarjuk tenni.A eljárást abba az osztályba (class) kell írni, ahol a Main() van, de a Main()-en kívül.Állhat a Main() előtt és után is.
6/1. PéldaÍrjuk meg a következő kiir eljárást: Kiírja a képernyőre: Hello +Enter leütésére vár.Hívjuk meg a főprogramban.
static void kiir() // static: azért kell, mert egyébként nem látja a Main()-ből// void: olyan függvény, aminek nincs visszatérési értéke, a Main() is egy függvény
{ Console.WriteLine("Hello"); Console.ReadLine(); } static void Main() { kiir(); }
6/2 PéldaAz eljárások nem látják egymás változóit. Ezért az eljárásokon kívül kell ezeket definiálni, static jelzővel.Nem kell hogy megelőzze az eljárásokat. Ha nem írom be a static-ot akkor nem látják az eljárások.A változók hatásköre az őket tartalmazó blokkra (pl. függvényre) terjed ki.Ha egy változót a Main()-en belül definiálunk, akkor más eljárásból nem láthatjuk azt.Ha egy változót egy eljáráson belül definiálunk, akkor más eljárásból nem láthatjuk azt.Azokat a változókat, amelyeket szeretnénk megosztani az eljárásaink között, azokat az eljárásokat összefogó osztály (class) belsejében, de az eljárásokon kívül kell deklarálni. )A főprogramban egy a változónak értéket adunk pl. a=10; Írjunk eljárást, ami ezt a változót kiíratja.
static int a; static void kiir() { Console.WriteLine(a); Console.ReadLine(); } static void Main() { a = 10; kiir(); }
6/3. Példa Készítsünk egy eljárást: beolvas, ami beolvas 2 egész számot. Egy másik eljárást: szamol, ami összeadja a két számot. Egy harmadikat: kiir, ami kiírja a végeredményt. A főprogramban hívjuk meg az eljárásokat.
45
static int a, b, c; static void Main() { beolvas(); szamol(); kiir(); } static void beolvas() { Console.WriteLine("Adj meg 2 egészet"); Console.Write("a= "); a = Convert.ToInt32(Console.ReadLine()); Console.Write("b= "); b = Convert.ToInt32(Console.ReadLine()); } static void kiir() { Console.WriteLine("\nA két szám összege="+c); Console.ReadLine(); } static void szamol() { c = a + b; }
6/4 PéldaKérjünk be egy 5 elemű vektor elemeit billentyőzetről, majd írjuk ki a vektor elemeinek értékét a képernyőre egy sorban egymás mellé vesszővel elválasztva, majd számoljuk ki és írjuk ki a képernyőre avektor elemeinek összegét. Eljárások: Feltoltes, Kiiras, OsszegSzamitas.
static int[] tomb = new int[5]; static int osszeg = 0; static void Main() { Feltoltes(); Kiiras(); OsszegSzamitas(); Console.WriteLine("A tomb elemek osszege= "+osszeg); Console.ReadLine(); } static void Feltoltes() { Console.WriteLine("Adj meg 5 egészet"); for (int i = 0; i < tomb.Length; i++) { Console.Write("A tomb {0}. eleme=", i); tomb[i] = Int32.Parse(Console.ReadLine()); } } static void Kiiras() { Console.WriteLine("\nA tomb elemei: "); for (int i = 0; i < tomb.Length; i++)
46
Console.Write(tomb[i]+" "); Console.WriteLine(); } static void OsszegSzamitas() { osszeg = 0; for (int i = 0; i < tomb.Length; i++) osszeg = osszeg + tomb[i]; }
Függvények 1. A függvények olyan eljárások, amelyeknek van visszatérési értéke.
6/5 PéldaA főprogramban olvassunk be 2 egész számot (a,b). Készítsünk függvényt, ami kiszámolja a két szám összegét. A főprogramban hívjuk meg a függvényt, és írassuk ki az eredményt.
static int a, b; static int osszeg() { int seged; seged = a + b; return seged; } static void Main() { Console.WriteLine("Adj meg 2 egészet!"); a = Int32.Parse(Console.ReadLine()); b = Int32.Parse(Console.ReadLine()); int ossz; ossz = osszeg(); Console.WriteLine("A két szám összege= " + ossz); Console.ReadLine(); }
// vagy: Console.WriteLine("A két szám összege= " + osszeg());
6/6 PéldaKérjük be egy 5 elemű vektor elemeit billentyűzetről (Eljárás: Feltoltes). Ezt már megírtuk az eljárásoknál.Számoljuk ki vektor elemeinek összegét. (függvény: Osszeg )Írjuk ki a képernyőre az eredményt. (Eljárás: Kiir).
static int[] tomb = new int[5]; static int ossz = 0; static void Feltoltes() { Console.WriteLine("Adj meg 5 egészet"); for (int i = 0; i < tomb.Length; i++) { Console.Write("A tomb {0}. eleme=", i); tomb[i] = Int32.Parse(Console.ReadLine()); } }
47
static int Osszeg() { int i,seged=0; for (i = 0; i < 5; i++) seged = seged + tomb[i]; return seged; } static void Kiir() { Console.WriteLine("A tömb elemeinek összege= " + ossz); Console.ReadLine(); } static void Main() { Feltoltes(); ossz = Osszeg(); Kiir(); }
Eljárások, függvények 2.Paraméterek használata.
6/7 Példa Készítsünk eljárást (Szamol), aminek bemenő paramétere 2 egész szám. Kiírja a két szám összegét a képernyőre.A főprogramban beolvasunk 2 egészet, meghívjuk az eljárást.
static void Szamol(int a, int b) { Console.WriteLine("A két szám összege= "+(a+b)); Console.ReadLine(); } static void Main() { int x, y; Console.WriteLine("Adj meg 2 egészet!"); x = Int32.Parse(Console.ReadLine()); y = Int32.Parse(Console.ReadLine()); Szamol(x, y); }
6/8 PéldaMint az előző példa, de a beolvasás is eljárás legyen(Beolvas).
static int x, y; static void Beolvas() { Console.WriteLine("Adj meg 2 egészet!"); x = Int32.Parse(Console.ReadLine()); y = Int32.Parse(Console.ReadLine()); } static void Szamol(int a, int b) { Console.WriteLine("A két szám összege= "+(a+b));
48
Console.ReadLine(); } static void Main() { Beolvas(); Szamol(x, y); }
6/9 PéldaKérjünk be egy 5 elemű vektor elemeit billentyőzetről (Eljárás: Feltoltes). Ezt már megírtuk az eljárásoknál. Készítsünk eljárást (Kiiras, paramétere a tömb) , ami kiírja a tömb elemeit egymás mellé szóközzel elválasztva.
A főprogramban meghívjuk a két eljárást. static int[] tomb = new int[5]; static void Feltoltes() { Console.WriteLine("Adj meg 5 egészet"); for (int i = 0; i < tomb.Length; i++) { Console.Write("A tomb {0}. eleme=", i); tomb[i] = Int32.Parse(Console.ReadLine()); } } static void Kiiras(int[] x) { Console.Write("A tomb elemei: "); for (int i = 0; i < x.Length; i++) Console.Write("{0}, ", x[i]); Console.ReadLine(); } static void Main() { Feltoltes(); Kiiras(tomb); }
49
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:- Készítsünk egy függvényt, aminek bemenő paramétere: a: egész. Kiszámolja a
b=5*a2+7*a+14 értéket.A főprogramban írassuk ki 2 oszlopban: 1. oszlop: számok 1-10, Második oszlop: a függvény értéke.
- Készíts eljárást, ami kiírja egymás alá az első 20 négyzetszámot.Az eljárást hívd meg a főprogramban.
- 5 elemű egészekből álló tömb.1. eljárás: beolvassa az elemeket. Már megírtuk2. eljárás: kiírja az elemek közül a legnagyobbat.Főprogramban meghívjuk a két eljárást.
- 5 elemű egészekből álló tömb.1. eljárás: Beolvassa a tömb elemeit, de úgy hogy csak pozitív számot enged meg.2. eljárás: Kiírja: növekvő, csökkenő, vagy rendezetlen a tömb.
- Készítsünk olyan függvényt, amely kap paraméterként két számot, és visszaadja a két szám közül a nagyobbik értékét! Amennyiben a két szám egyenlő, úgy az első szám értékét kell visszaadni!Hívjuk meg a függvényt a következő értékekkel a főprogramban, és írassuk ki az a függvény eredményét:5,7 10,5 15,15 -> Kiírja: 7,10,15
Az eljárás és függvény paramétere nem csak bemenő, hanem kimenő is lehet.Megadható, hogy a paraméter az eljárás végrahajtása után megváltozzon vagy ne.Amit azt akarjuk hogy változzon meg elé kell írni a ’ref’ kulcsszót ( referencia ).
6/10 PéldaMit ír ki a következő program static void Eljaras(int a, ref int b) { a = 5; b = 10; } static void Main(string[] args) { int x=1, y=2; Eljaras(x,ref y);
// hívás helyén is jelölni kell, hogy az átadott változóban kimenı adatokat várunk. Console.WriteLine(x + "," + y); Console.ReadLine(); }
Kiírja: 1,10
Az un. referencia típusok ( ilyen a tömb is) akkor is megváltoztathatóak amelyeknél nem írjuk oda, hogy ref.referencia típusok: amelyeknél a new kulcsszóval helyet foglalunk le a memóriában.
6/11 PéldaMit ír ki?
static void Eljaras(int[] x) { x[0] = 10; }
50
static void Main(string[] args) { int[] y = new int[2]; y[0] = 5; y[1] = 7; Eljaras(y); Console.WriteLine(y[0] + "," + y[1]); Console.ReadLine(); }
Kiírja: 10,7
Előnye: függvénynek 1 kimeneti értéke lehet.Paramétereken keresztül akármennyi értéket kiszámoltathatunk.
6/12 PéldaKészítsünk eljárást 2 visszatérési értékkel:
1. paraméter(csak bemeneti): kör sugara2. paraméter( kimeneti is) : kör kerülete3. paraméter(kimeneti is): kör területe
A főprogramban olvassuk be a sugár értékét. Írjuk ki: kerület, terület.
static void KeruletTerulet(double r, ref double ker, ref double ter) { ker = 2 * r * Math.PI; ter = r * r * Math.PI; } static void Main(string[] args) { Console.Write("Add meg a sugár értékét!\nr= "); double r,ker,ter;
// Lehet azonos az eljájás paraméter nevével. // Az eljárás hívásakor átadja az értéket.
r = Convert.ToDouble(Console.ReadLine()); ker = 0; ter = 0; // Érték nélkül hibát ír ki a köv. eljárásnál. KeruletTerulet(r, ref ker, ref ter); Console.WriteLine("Kerület= " + ker); Console.WriteLine("Terület= " + ter); Console.ReadLine(); }
Rekurzió
6/13 PéldaKészítsünk függvényt egy szám faktoriálisának kiszámolására rekurzióval. Főprogramban kiíratni 2 oszlopban: 1-től 10-ig , mellé faktoriálisa
(Ciklussal már megcsináltuk az 1. fejezetben)
static int fakt(int n) { if (n == 1) return 1; else return fakt(n - 1) * n; }
51
static void Main(string[] args) { for(int i=1;i<=10;i++) Console.WriteLine(i+" "+fakt(i)); Console.ReadLine(); }
6/14 PéldaKészítsünk függvényt az N. Fibonacci szám előallítására rekurzióval. Majd segítségével írassuk ki egymás alá az első 10 Fibonacci számot.Fibo(0) = 0; Fibo (1) = 1; Fibo (n) = Fibo (n − 1) + Fibo (n − 2)0, 1, 1, 2, 3, 5, 8, 13…
static int Fibo(int n) { if (n == 0) return 0; else if (n == 1) return 1; else return Fibo(n - 1)+ Fibo(n-2); } static void Main(string[] args) { for(int i=1;i<=10;i++) Console.WriteLine(i+" "+Fibo(i)); Console.ReadLine(); }
Házi feladatB, megoldás rekurzív függvény nélkül:100 elemű tömbbe vegyük fel az elemeket, majd írassuk ki a tömb elemeit.
Metódusok túlterhelése. ( Overloading )Lehet két ugyanolyan nevű metódus, ha az argumentumlistái különbözőek:
6/15 Példa
using System;class elso{ static void kiir(int a) { Console.WriteLine(a); } static void kiir(int a,int b) { Console.WriteLine(a+" "+b); } static void Main() { kiir(5); kiir(7, 9); Console.ReadLine(); }}
52
A túlterhelés azt jelenti, hogy egy adott szót vagy nevet több dologra is használunk.
6/16. Példa
using System;class Fo{ static void kiir() { Console.WriteLine("Kiir-1"); } static void kiir(int a) { Console.WriteLine("Kiir-2"); } static void kiir(double a) { Console.WriteLine("Kiir-3"); } static void Main() { kiir(); kiir(5); kiir(5.2); Console.ReadLine(); }}
6/17 PéldaEbben a példában a túlterhelt metódusnál a paraméterek száma megegyezik, de típusuk különböző:
using System;class elso{ static double osztas(double a, double b) { return a / b; } static int osztas(int a, int b) { return a / b; } static void Main() { Console.WriteLine(osztas(22,7)); Console.WriteLine(osztas(22.0, 7.0)); Console.ReadLine(); }}
Kiírja: 3 3,1428
53
7. List ( lista ) - ArrayList
A List és az ArrayList előnyei: nem kell előre tudni a beolvasott elemek számát, könnyű új elemet hozzá adni, könnyű elemet törölni.
Lista - List
A List hasonló az ArrayList-hez, de csak azonos típusú adatokat tudunk benne tárolni.
7/1 Példa
using System;using System.Collections.Generic; // Ez is kell.
class Program{ static void Main() { List<int> lista1 = new List<int>(); for (int i = 0; i < 10; ++i) { lista1.Add(i); } // Az Add metódus a lista végéhez adja hozzá a paraméterként // megadott elemet, hasonlóan az ArrayList–hez. foreach (int adat in lista1) { Console.WriteLine(adat); } Console.ReadLine(); Random r = new Random(); for (int i = 0; i < 10; ++i) { lista1.Add(r.Next(15)); } // A lista elemeit könnyen rendezhetjük a Sort metódussal lista1.Sort(); Console.WriteLine(); foreach (int adat in lista1) { Console.WriteLine(adat); } Console.ReadLine(); // új elem beszúrása: // Az 5. helyre beszúr egy 1000-es étéket. lista1.Insert(5, 1000); Console.WriteLine(); foreach (int adat in lista1) { Console.WriteLine(adat);
54
} Console.ReadLine(); // A lista egy elemének törlése: // törli a 12. elemet: lista1.RemoveAt(12); Console.WriteLine(); foreach (int adat in lista1) { Console.WriteLine(adat); } Console.ReadLine(); // a lista elemszámának kiíratása: Console.WriteLine(lista1.Count); Console.ReadLine(); } }
A listánhoz sok metódus tartozik:beírjuk:lista1.és kiírja a felhasználható metódusokat.
Az List főbb jellemzői:Capacity: az elemek számát olvashatjuk illetve írhatjuk elő.Count: az elemek számát olvashatjuk ki.
Az List főbb metódusai:Add: Hozzáad egy objektumot a lista végéhez.BinarySearch: Rendezett listában a bináris keresés algoritmusával megkeresi azelemetClear: Minden elemet töröl a listából.CopyTo: Átmásolja az List-át egy egydimenziós tömbbe.IndexOf: A megadott elem első előfordulásának indexét adja vissza. A lista elsőelemének az indexe a 0.Insert: Beszúr egy elemet az Listbe a megadott indexhez.Sort: Rendezi az elemeket az Listben.
7/2 Példa
class Program{ static void Main() { List<int> lista1 = new List<int>(); for (int i = 0; i < 10; ++i) { lista1.Add(i*i); } foreach (int adat in lista1) { Console.WriteLine(adat); } Console.WriteLine("A lista tartalmazza-e az 16-os számot? "+ lista1.Contains(16)); // True Console.WriteLine("A lista tartalmazza-e az 20-as számot? " + lista1.Contains(20)); // False
55
Console.WriteLine("Hányadik elem az 16-os szám? " + lista1.IndexOf(16)); // 4 Console.WriteLine("Hányadik elem az 20-as szám? " + lista1.IndexOf(20)); // -1 Console.ReadLine(); }
ArrayList - Dinamikus méretű vektorokDinamikus elemszámú tömbök kezelését valósítja meg az ArrayList osztály.Az elemek különböző típusúak is lehetnek.
using System;using System.Collections; // ez kellclass Program{ static void Main() { ArrayList elemek = new ArrayList(); elemek.Add("Hello"); // Add: a lista végére tesz egy elemet. elemek.Add(25); int i; for(i=1;i<=8;i++) elemek.Add(i); Console.WriteLine("A dinamikus tömb elemei:"); for (i = 0; i < elemek.Count; i++) Console.WriteLine(elemek[i]); Console.WriteLine(); elemek.Insert(5, 100); // Beszúr egy új elemet az 5. helyre foreach (object o in elemek) Console.WriteLine(o);
Console.WriteLine("A tömb elemeinek a száma=" + elemek.Count); elemek.RemoveAt(7); // törli a 7. elemet foreach (object o in elemek) Console.WriteLine(o); Console.WriteLine("A tömb elemeinek a száma=" + elemek.Count); Console.ReadLine(); }}
56
8. Struktúra ( Rekord, Struct )
Egy sima tömbben az adatok csak azonos típusúak lehetnek. Ha különböző típusú adatokat szeretnénk kezelni, akkor azokat struktúrában érdemes tárolni. A struktúradefiniálás lehetővé teszi, hogy az összetartozó adatokat egy egységként tudjuk kezelni.
A struktúrát gyakran tömbbel együtt használjuk. Például sok személy adatát tároljuk. Minden személyről eltároljuk a nevét, életkorát, magasságát… Egy személy adatait (név, életkor, magasság…) struktúrában tároljuk. Az adatokat együttesen egy tömbben tároljuk. ennek a tömbnek az elemei ilyen struktúra típusúak.
A struktúrákat nem csak tömbben, hanem listában is lehet tárolni.
A struktúradefiníció formája a következő:
struct név {
hozzáférés típus mezőnevek;…hozzáférés függvénydefiníció ;
};
Hivatkozás egy mezőre: változónév.mezőnévA struktúrákon azonos típus esetén az értékadás elvégezhető, így ha például
a és b azonos típusú struktúra, akkor az a=b értékadás szabályos, és az a mindenmezője felveszi b megfelelő mezőértékeit.A struktúrát a Main()-en kívül adjuk meg.
8/1 PéldaEgy rekordban tároljuk egy személy adatait ( nev, cim, kor). Adjuk meg a személy 3 adatát, majd írassuk ki a képernyőre. Majd olvassunk be másik 3 adatot, majd írassuk ki a képernyőre.
struct szemely // szemely: ez a struktúra neve { public string nev; // public: egyébként kívülről nem látszana public string cim; public int kor; } static void Main(string[] args) { szemely adat; // Az adat nevű változó szemely típusú // vagy: szemely adat=new szemely(); adat.nev="Kovács Ferenc"; adat.cim = "Szolnok"; adat.kor = 25; Console.WriteLine(adat.nev+"\n"+adat.cim+"\n"+adat.kor); Console.ReadLine(); Console.WriteLine("Add meg egy személy 3 adatát."); Console.Write("Név="); adat.nev=Console.ReadLine(); Console.Write("Cím="); adat.cim = Console.ReadLine(); Console.Write("Életkor="); adat.kor = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("A személy adatai:");
57
Console.WriteLine(adat.nev + "\n" + adat.cim + "\n" + adat.kor); Console.ReadLine(); }
8/2 Példa5 versenyző adatát beolvassuk. ( név, cím, pont). Írassuk ki az 5 személy adatát 3 oszlopban.Kiszámoljuk a pontok átlagát és kiíratjuk azt. Majd kiíratjuk azon személyek nevét és pontját, akinek pontja nagyobb mint az átlag.
struct rekord { public string nev; // public: egyébként kívülről nem látszana public string cim; public int pont; } static void Main(string[] args) { rekord[] szemelyek = new rekord[5]; Console.WriteLine("Add meg 5 szemelyek adatát (nev, cim, pont)"); int a; for (a = 0; a <= 4; a++) { Console.WriteLine(a + ". személy adatai:"); Console.Write("Név="); szemelyek[a].nev = Console.ReadLine(); Console.Write("Cím="); szemelyek[a].cim = Console.ReadLine(); Console.Write("Pont="); szemelyek[a].pont = Convert.ToInt32(Console.ReadLine()); } Console.WriteLine("Az 5 személy adata:"); for (a = 0; a <= 4; a++) Console.WriteLine("{0,20}{1,20}{2,20}", szemelyek[a].nev, szemelyek[a].cim,
szemelyek[a].pont); double atlag = 0; for (a = 0; a <= 4; a++) atlag = atlag + szemelyek[a].pont; atlag = atlag / 5; Console.WriteLine("A pontok átlaga= " + atlag); Console.WriteLine("Az átlagnál több pontot értek el:"); for (a = 0; a <= 4; a++) if(szemelyek[a].pont>atlag) Console.WriteLine("{0,20}{1,20}", szemelyek[a].nev, szemelyek[a].pont); Console.ReadLine(); }
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:5 személy adatát beolvassuk. ( név, cím, pont).Rendezze növekvő sorrendbe az adatokat a pont szerint. Majd írassa ki a rendezett adatokat.
58
9. Fájlkezelés
A program elején használni kell a using System.IO;utasítást. A fájlkezelő utasítások a System.IO névtérben vannak.
9/1 példaÍrjuk ki a Teszt.txt fájlba a következőt:Hello1Hello2Hello3
static void Main(){ StreamWriter fajl1 = new StreamWriter("Teszt.txt");
// fájl1 logikai nevet rendeli a Teszt.txt fizikai fájlhoz.// Ha a fájl létezik, akkor letörli azt.// Írásra megnyitja a fájlt.
fajl1.WriteLine("Hello1"); fajl1.WriteLine("Hello2"); fajl1.WriteLine("Hello3"); fajl1.Close(); // Lezárja a fájlt. Console.WriteLine("Fájlba adatok kiírva"); Console.ReadLine();}
A fájlt oda menti, ahova a Project-et mentettük ( File menü/Save All)pl. ha a Project-et a C:\ide könyvtárba mentettük, akkor a fájl a következő könyvtárban jön létre:C:\ide\ConsoleApplication1\ConsoleApplication1\bin\Debug
A fájl lezáráskor írja ki a fájl teljes tartalmát a memóriából a háttértárra.
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:Írassuk ki az egészeket 1-10-ig a c:\ide könyvtárba a Teszt.txt fájlba.
9/2 PéldaÍrassa ki a c:\ide\Teszt.txt fájl tartalmát a képernyőre.
Fájl meglétének ellenőrzése: if (File.Exists("c:\\kep1.jpg"))
…….
static void Main(){ StreamReader fajl1 = new StreamReader("c:\\ide\\Teszt.txt"); string sor; Console.WriteLine("A c:\\ide\\Teszt.txt fájl tartalma:");
while (!(fajl1.EndOfStream)) {
59
sor = fajl1.ReadLine(); Console.WriteLine(sor); } fajl1.Close(); Console.ReadLine();}
// EndOfStream: igaz, ha a fájl végén áll a pozíció, különben hamis.
VAGY:while (fajl1.EndOfStream == false)……..
VAGY:
while ((sor = fajl1.ReadLine()) != null) Console.WriteLine(sor);
VAGY:
while (fajl1.Peek() >= 0) { sor = fajl1.ReadLine(); Console.WriteLine(sor); }
Peek(): a következő karakter kódját kapjuk a fájlból, de nem módosul a fájlpozíció.A fájl végén a Peek() értéke= -1
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:- Írassa ki a képernyőre a c:\ide\adat1.txt fájl páros sorait.- Írassa ki egymás után a c:\ide\ adat1.txt és az adat2.txt fájl tartalmát.
B megoldás: eljárással:- Írassa ki oldalanként ( 20 soronként ) a c:\ide\adat1.txt fájl tartalmát.
Oldalanként billentyű leütésre várjon.- Írassa ki hogy hány sorból áll az adat1.txt fájl.
( megoldás: Minden sor beolvasásnál növeljük 1-el a db változó értékét.) - Írassa ki hogy hány karakterből áll a c:\ide\adat1.txt fájl.
(Megoldás: A sorok hosszát: sor.Length összegezzük egy változóban )- Írassa ki az adat1.txt fájl méretét bájtokban.
( Megoldás: mint az előző, de minden sornál az összeghez hozzá adunk még 2-t, mertminden sor végét +2 karakter zárja le: következő sorba+ sor elejére ugrás. )
b. megoldás: Karakterenként olvasunk a fájlból.fajl1.Read(): beolvas egy karaktert és a következőre ugrik
9/3 PéldaKészítsen másolatot az adat1.txt fájlról adat3.txt néven.
Fájl olvasás + fájl írás
static void Main(){ StreamReader fajl1 = new StreamReader("c:\\ide\\adat1.txt");
60
StreamWriter fajl2 = new StreamWriter("c:\\ide\\adat3.txt"); string sor; while (!(fajl1.EndOfStream)) { sor = fajl1.ReadLine(); fajl2.WriteLine(sor); } fajl1.Close(); fajl2.Close(); Console.WriteLine("A fájl kiírva"); Console.ReadLine();}
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:Másolja át az adat1.txt fájl páratlan sorait az adat4.txt fájlba.
static void Main(){ StreamReader fajl1 = new StreamReader("c:\\ide\\adat1.txt"); StreamWriter fajl2 = new StreamWriter("c:\\ide\\adat4.txt"); string sor; int db = 0; while (!(fajl1.EndOfStream)) { sor = fajl1.ReadLine(); db++; if(db%2==1) fajl2.WriteLine(sor); } fajl1.Close(); fajl2.Close(); Console.WriteLine("A fájl kiírva"); Console.ReadLine();}
9/4. példaKiíratja a fájl tartalmát a képernyőre, de nem sorokat, hanem karaktereket olvas be.
static void Main(){ StreamReader fajl1 = new StreamReader("c:\\ide\\adat1.txt"); int d; while (!(fajl1.EndOfStream)) { d=fajl1.Read(); Console.Write(Convert.ToChar(d)); } fajl1.Close(); Console.ReadLine(); }
d=fajl1.Read(): A karakter ASCII kódját adja eredményül.
61
9/5. példaÍrja az adat1.txt fájlt az adat4.txt végéhez. ( Hozzáfűzés )
static void Main(){ StreamReader fajl1 = new StreamReader("c:\\ide\\adat1.txt"); StreamWriter fajl2 = new StreamWriter("c:\\ide\\adat4.txt",true);
// true: hozzáfűzésre (append) nyitja meg string sor; while (!(fajl1.EndOfStream)) { sor = fajl1.ReadLine(); fajl2.WriteLine(sor); } fajl1.Close(); fajl2.Close(); Console.WriteLine("A fájl kiírva"); Console.ReadLine();}
Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:- Írassa ki az adat1.txt fájl 11-18 sorát a képernyőre.
(Megoldás: Beolvasom az 1-18 sort. És a 11-18 sornál kiíratom a képernyőre.)- Írassa ki 3 oszlopban az adat1.txt fájlba:
1. oszlop: számok 1-10 –ig2. oszlop: a szám négyzete3. oszlop: a szám gyökeMindhárom oszlop 10 karakter széles legyen és legyen fejléc. A valós értékeket 3 tizedes jegyen jelenítse meg.
- Másolja át az adat1.txt fájlt az adat3.txt-be úgy hogy minden sor után beír plusz egy sort, ami 25 db ’*’ karaktert tartalmaz.
9/6. példaAz adat1.txt fájlban keresse meg melyik sorokban szerepel az ’ablak’ szó.Írassa ki a sor számát, és mellé a teljes sort a képernyőre.
static void Main(){ StreamReader fajl1 = new StreamReader("c:\\ide\\adat1.txt"); string s; Console.WriteLine("A c:\\ide\\adat1 fájlban a következő sorokban szerepel az ablak szó:"); int db = 0; while (!(fajl1.EndOfStream)) { s = fajl1.ReadLine(); db++; if(s.IndexOf("ablak")>-1) Console.WriteLine(db+": "+s); } fajl1.Close(); Console.ReadLine();
62
}9/7 PéldaIrja ki (másolja ki) a következő számsorozatokat a c:\feladat\be.txt fájlba pl. Jegyzettömbbel.( 8 sor. Minden sorban 6 egész szám, szóközökkel elválasztva )
9 3 14 3 10 179 8 19 12 5 99 9 29 7 10 199 10 58 10 19 179 12 0 19 20 89 16 17 3 17 519 18 34 8 8 129 22 12 13 7 11
Programmal olvassa be az adatokat. Töltse az adatokat egy 8*6-ös tömbbe.Írassa ki a képernyőre a tömb alapján a sorok összegét.( Érdemes felhasználni a sztringeknél tanult Split utasítást)
StreamReader fajl1 = new StreamReader("c:\\feladat\\be.txt"); string sor; int[,] t = new int[8, 6]; string[] szamok; int i=-1, j; while (!(fajl1.EndOfStream)) { i++; sor = fajl1.ReadLine(); szamok = sor.Split(' '); for (j = 0; j < 6; j++) t[i, j] =Convert.ToInt32(szamok[j]); } Console.WriteLine("\nA sorok összege:"); int osszeg; for (i = 0; i < 8; i++) { osszeg = 0; for (j = 0; j < 6; j++) osszeg= osszeg+t[i, j]; Console.WriteLine(i+". sor: "+osszeg); } fajl1.Close(); Console.ReadLine();
Házi feladatA be.txt-ben számok vannak több sorban. Minden sorban több szám lehet szóközzel elválasztva.Lehet hogy vannak többszörös szóközök a számok között.Készítse el a ki.txt fájlt: Minden sorhoz írassa ki a számok átlagát. Az eredeti sort már nem kell újra kiírni
sor.Split-el darabolni, ahogy a Stringeknél láttuk.
63
Beadandó Házi feladathoz:
Ha a magyar ékezetes karakterek nem jól jelennek meg a kiíratáskor, akkor a fájl és a kiíratás kódolása nem megegyező.
1. A fájl beolvasásnál a kódolást meg kell adni: pl. StreamReader fajl1 = new StreamReader("c:\\ide\\adat1.txt",Encoding.UTF7);vagy pl. Encoding.UTF7 vagy Encoding.UnicodeEncoding. –ot beírva a lehetőségekből választani.
A suzo.uw.hu => Office => Adatbazis-kezelés => - Kosarlabda.zip fájlokhoz (pl. jatekos.txt) az Encoding.UTF7 kell.
Lásd következő példa!- Vizvezetek-szerelok.zip fájlok ( pl. hely.txt ) UTF-8 kódolásúak.
Jegyzettömbben Fájl menü => Mentés másként => Kódoláslátszik az UTF-8 kódolás.
De a StreamReader fajl1 = new StreamReader("c:\\ide\\adat1.txt");is jól megnyitja.
Így is jó:StreamReader fajl1 = new StreamReader("c:\\ide\\adat1.txt",Encoding.UTF7);
VAGY2. A Jegyzettömbben a fájlt más kódolásban kell elmenteni:
Fájl menü => Mentés másként => Kódolás pl. Unicode vagy ANSI, vagy UTF-8
Az 1. módszer a jobb, a több pontot érő megoldás.
Ha a sorban az adatok tabulátorral vannak tagolva, akkor a Split-et így kell hasznáni:string[] szovegek;szovegek = sor.Split('\t');Lásd következő példa:
Beadandó házi feladathoz:Házi feladat:Struktúrált programozás-Feladatok.doc-ban van a megoldás:- A suzo.uw.hu => Office => Adatbazis-kezelés => Kosarlabda.zip => jatekos.txt fájl tartalmát
írassa ki a képernyőre- Az előző példában a fájl soraiban az adatok tabulátorral vannak tagolva. (Ez Jegyzettömbben is látható!)
Olvassa be az adatokat egy tömbbe. (Sztring típusú tömb) (Split-el darabolni)A tömbnek annyi sora legyen, mint amennyi adatsor van a fájlban. ( Ezt programmal számoltassa meg először)Majd számítsa ki a magasságok átlagát, és írassa ki az átlagot.
64
10. Kivételkezelés
A C# nyelv a futásidejű hibák kiszűrésére alkalmas eszközt is tartalmaz, mely eszközsegítségével a programjainkba hibakezelő (kivétel kezelő) kódrészleteket építhetünk.A kivétel kezelő eljárások lényege, hogy elkerüljük a futás közbeni hibák esetén felbukkanóhibaüzeneteket, és megvédjük programjainkat a váratlan leállástól.
A try és a catch
A try parancs segítségével a programok egyes részeihez hibakezelő rutinokat rendelhetünk,melyek hiba esetén az általunk megírt hibakezelő eljárásokat hajtják végre, s ami nagyonfontos, megakadályozzák a program leállását.
A catch segítségével azokat a kivételeket kaphatjuk el, melyek a try blokkban keletkeznek. Itthatározhatjuk meg, hogy milyen rutinok fussanak le és hogyan kezeljék a felmerülő hibákat.
Kivételkezelés nélkül a program a hiba helyén megszakad.
Kivételkezelés:A program futása nem szakad meg hibás működés esetén, hanem egy másik programrészlet hajtódik végre.
10.1 Példausing System;class elso{ static void Main() { try { Console.WriteLine("Hello1"); int[] tomb1 = new int[10]; tomb1[15] = 3; // A 10 elemű tömb 15. elemére hivatkozunk Console.WriteLine("Hello2"); } catch (Exception e) { Console.WriteLine("hiba: " + e.Message); } finally { Console.WriteLine("Hello3"); Console.ReadKey(); } }}A következőt írja ki:Hello1hiba: Index was outside the bounds of the arrayHello3
A finally blokkban elhelyezett kód mindig lefut, függetlenül az elıtte keletkezett hibáktól.(kivéve ha a program végzetes hibával áll le.)
65
Az előző programban ez is jó:---------------------- catch (Exception) { Console.WriteLine("hiba: "); }----------------------
Ilyenkor a kiírás:
Hello1hiba: Hello3
vagy (Exception) nélkül:
---------------------------------- catch { Console.WriteLine("hiba: "); }----------------------------------A kiíratás ugyanaz.
A catch blokkban definiált hibakezelő rész lefut, vagyis a képernyőn megjelenik a hibaüzenet.Abban az esetben, ha nem használjuk a hibakezelő eljárásokat, a programunk leáll, és ahiba kezelését a .NET vagy az operációs rendszer veszi át. Ebből a példából is jól láthatómilyen nagy szükség lehet a kivételkezelőre, ha jól működő programokat akarunk írni.Fokozottan érvényes ez azokra a programokra, ahol a felhasználó adatokat visz be.
A következő programban erre láthatunk példát. Amennyiben az inputról nem megfelelőadatok érkeznek, működésbe lép a kivétel-kezelés, a catch blokkban elkapjuk a hibát éskiírjuk az okát a képernyőre.
10.2 Példa
using System;class Program{ static void Main() { try { Console.WriteLine("Adj meg egy egészet!"); int i = Convert.ToInt32(Console.ReadLine()); } catch (Exception e) { Console.WriteLine(e.Message); } Console.ReadLine(); }}
Ha a beolvasásnál nem egész számot adunk meg, hanem pl. egy szöveget, akkor a következő hibaüzenetet kapjuk:
Input string was not in a correct format.
66
10.2/B PéldaMint az előző példa, de addig olvassuk be az adatot, amíg nem egész jön.Ha egész jön, akkor írjuk ki a kétszeresét.
class Program{ static void Main() { bool ujra = true; Console.WriteLine("Adj meg egy egészet!"); while (ujra) { try { int i = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("A szám kétszerese: "+2 * i); ujra = false; } catch (Exception e) { Console.WriteLine("Nem egészet adtál meg! Próbálkozz újra!"); } } Console.ReadLine(); }}
Az előző példában a try blokkban előforduló bármely hiba esetén ugyanaz a hibaüzenet jelenik meg a képernyőn.
A catch blokkban lehetőségünk van a különböző okok miatt keletkezett hibákszétválasztására, a hiba típusának meghatározására.
A System névtérben rengeteg kivétel típust definiáltak. A fontosabbakat az alábbitáblázatban foglaltuk össze:
Kivétel neve LeírásaMemberAccesException Tagfüggvény hozzáférési hibaArgumentException Hibás tagfüggvény-paraméterArgumentNullException Null értékű tagfüggvény paraméterArithmeticException Matematikai művelet-hibaArrayTypeMismatchException Tömbtípus hibája (érték tároláskor)DivideByZeroException Nullával való osztásFormatException Hibás paraméter-formátumIndexOutOfRangeException Tömb túl, vagy alulindexeléseInvalidCastException Érvénytelen típus átalakításNotFiniteNumberException A keletkezet érték nem véges
(hibás számalak)NullReferenceException Null értékre való hivatkozásNotSupportedException Nem támogatott tagfüggvényOutOfMemoryException Elfogyott a memóriaOverflowException Túlcsordulás (checked esetén)StackOverflowException Verem túlcsordulásTypeInitializationException Hibás típus beállítás (static
67
konstruktornál)
10.3 Példa
A Matematikai művelet-hibára egy példa:
using System;class Program{ static void Main() { int a = 0; double c; try { c = 10 / a + 30; } catch (ArithmeticException ar) { Console.WriteLine("Aritmetikai hiba : "+ar); Console.ReadLine(); }
}}
0-val való osztásra egyébként egy hibaüzenet ablak jelenik meg.
Kivételek feldobása - throw
A C# nyelv lehetőséget ad a saját magunk által definiált kivételek használatára is. A kivételekdobása a throw kulcsszóval történik.
Nemcsak a keretrendszer láthatja azt, hogy a normális utasítás végrehajtást nem tudja folytatni, ezért kivételt generál, és ezzel adja át a vezérlést, hanem maga a programozó is. Hogy a programozó mikor látja szükségesnek a kivétel generálását, az rá van bízva.
10.4 Példa
using System;class Program{ static void Main() { Console.WriteLine("Adj meg egy nem negatív számot!"); double i=Convert.ToDouble(Console.ReadLine()); try {
if (i>=0) Console.WriteLine("A szám gyöke= "+Math.Sqrt(i)); else throw new Exception(); // ha i<0, kivétel indul }
68
catch (Exception) { Console.WriteLine("Hibás számot írtál be!"); } finally { Console.WriteLine("Végül ez is lefut!"); Console.ReadLine(); } }}
10.5 Példa
Így is lehet, de hiba esetén egy üzenetablak jelenik meg.
using System;class Program{ static void Main() { Console.WriteLine("Adj meg egy nem negatív számot!"); double i=Convert.ToDouble(Console.ReadLine()); if (i>=0) Console.WriteLine("A szám gyöke= "+Math.Sqrt(i)); else throw new Exception("Hibás számot írtál be."); // ha i<0, kivétel indul Console.ReadLine(); }}
10.6 Példa
Amennyiben ilyen több-catch-es feldolgozást írunk, mindenképpen ügyeljünk az ágak megfelelő sorrendjére:
try { ... } catch (IOException) { ... } catch (FileNotFoundException) { ... } catch (Exception) { ... }
69
11.Lépésenkénti futtatás-NyomkövetésA hibakeresés fontos eszköze
Debug menüStep into (F11) - egyesével végrehajtja az utasításokat.Kilépés a lépésenkéánti futtatásból:Debud menü/Stop Debuging
Step into (F11): bele lép az eljárásokbaStep over (F10): nem lép bele az eljárásokba
Változók értékének figyelése a lépésenkénti futtatásnál:Debug menü => Windows =>
=> Locals: minden lokális változót mutat=> Watch: egyesével meg lehet adni változókat
Töréspontok elhelyezése.Debug menü => Toggle Breakpoint
A kurzor helyénél elhelyez egy töréspontot.A töréspontoknál megáll a program végrehajtása.
70
12. Egyéb
Halmaz – HashSet
using System.Collections.Generic;
static void Main(string[] args) { HashSet<int> szamok = new HashSet<int>(); Console.WriteLine(szamok.Count); szamok.Add(5); Console.WriteLine(szamok.Count); szamok.Add(5); Console.WriteLine(szamok.Count); szamok.Add(7); szamok.Add(9); Console.WriteLine(szamok.Count); foreach (int i in szamok) { Console.Write(" {0}", i); } Console.WriteLine(); int a = 7; if (szamok.Contains(a)) Console.WriteLine("Benne van."); else Console.WriteLine("Nincs benne."); szamok.Remove(5); Console.WriteLine(szamok.Count);
// Vannak halmaz műveletek: // Unio: szamok.UnionWith // Metszet: szamok.IntersectWith // Tömbbé letet konvertálni: // int[] tomb = hash.ToArray()
// És sok egyéb művelet. Console.ReadLine(); }
Queue – Sor
Sorba => => Sorból
FIFO modell: First In – First OutAmit először betettünk a sorba, azt tudjuk onnan kivenni.Főbb műveletek:Enqueue – A sorba betesz egy érétket
71
Dequeue – Sorból kivesz egy értéket.
using System;using System.Collections;class Program{ static void Main() { Queue sor = new Queue(); sor.Enqueue("Hello1"); sor.Enqueue("Szia"); sor.Enqueue(153); foreach (object o in sor) Console.WriteLine(o); Console.WriteLine("\nA sor elemeinek a száma= " + sor.Count); sor.Dequeue(); foreach (object o in sor) Console.WriteLine(o); Console.WriteLine("\nA sor elemeinek a száma= " + sor.Count); Console.ReadLine(); }}
Kiírja: Hello1Szia153……….Szia153
Valóban az elsőnek betett elemet törölte ki.
72
Felsorolás típus - Enum
A felsorolt típus olyan adatszerkezet, amely meghatározott értékek névvel ellátott halmazát képviseli. Felsorolt típust az enum kulcsszó segítségével deklarálunk, a Main()-en kívül.
A felsorolás minden tagjának megfeleltethetünk egy egész (numerikus) értéket. Ha mást nem adunk meg, akkor alapértelmezés szerint a számozás nullától kezdődik és deklaráció szerinti sorrendben (értsd: balról jobbra) eggyel növekszik.
class Program { enum szinek { piros, kék, zöld, sárga }; enum betuk { a = 'a', b = 'b' }; enum újszinek { piros = 4, kék = 7, zöld = 8, sárga = 12 }; static public void Main() { szinek sajatszin = szinek.zöld; Console.WriteLine(sajatszin+" "+(int)sajatszin+"\n"); // kiírja a színt //ciklus a színeken történő végighaladásra for (újszinek i = újszinek.piros; i <= újszinek.sárga; i++) { //kiírja a színeket Console.WriteLine(i+" "+(int)i);
} Console.ReadLine(); } }
Kiírja:zöld 2
piros 45 56 6kék 7zöld 89 910 1011 11sárga 12
Fa bejárás megvalósításaAlgoritmusok-ban:
- Fa bejárási algoritmusok - Ezt megvalósítani C#-ban.
- Ez felhasználható majd:- Könyvtárszerkezet kiíratása
- Grafikus programozás: TreeView- Könyvtárszerkezet kiíratása- TreeView tartalom feltérképezése
73
74
