Speciális valós értékek:
Adatok
float.PositiveInfinity, double.NegativeInfinity float.NaN, double.NaN (nem szám) float.Epsilon, Double.Epsilon – epsilon, a legkisebb ábrázolható pozitív szám
Deklarálás C#-ban: típus változónév; -
a változónév első karaktere csak betű vagy alulvonás (_) lehet, a többi karakter szám is a kis- és nagybetűk különböznek (x és X két különböző változó) azonos típusú változókat egymástól vesszővel elválasztva definiálhatunk
Karakterek
Pl. int a, b, A;
tárolásuk szintén binárisan történik ASCII 8 bites (1 bájtos): 0-31: vezérlőkarakterek, 32 – 127 :az angol ABC kis- és nagybetűi, számok, írásjelek, 128-255: rajzoló karakterek, speciális karakterek (csak az országok egy részének megfelelő) UNICODE kódolás: UTF-8 (az angol ABC betűinek kódolása ugyanaz, a többi karakternek egyedi karaktere van, 2-4 bájt), UTF-16 (a C# nyelv és a .NET keretrendszer belső kódolása), UTF-32 kódlapok minden karakteres típus, minden szövegkezelő függvény ez alapján működik Deklarálás: char c; // 2 byte hosszú Deklarálás és inicializálás: char c=’a’; (aposztróffal adjuk meg) Karakterlánc: string s=”alma”; (idézőjellel adjuk meg)
Értékadás: a = 10; a = b*3 – 2; a deklaráció és a kezdeti értékadás összevonható egy utasításba (deklaráció és inicializálás): pl. int a = 10; Egyszerű adattípusok: Számok: - egész számok byte - előjel nélküli egész, 1 bájton (0 .. 255) sbyte – előjeles egész, 1 bájton (-128 .. 127) ushort – előjel nélküli egész, 2 bájton (0 .. 65535) short – előjeles egész, 2 bájton (-32767 .. 32767) uint – előjel nélküli egész, 4 bájton (0 .. 4294967295) int – előjeles egész, 4 bájton (-2147483648 .. 2147483647) ulong – előjel nélküli hosszú egész, 8 bájton long – előjeles hosszú egész, 8 bájt Speciális értékek az egész számoknál: - MinValue: a legkisebb ábrázolható szám (pl. short.MinValue, int.MinValue, stb.) - MaxValue: a legnagyobb ábrázolható szám (pl. long.MaxValue, stb.)
Logikai típus - értéke igaz (true) vagy hamis (false) - deklarálás: bool jo; bool h = true; - logikai műveletek: és: &&, vagy: ||, tagadás: ! Típuskonverzió: -
- valós (lebegőpontos) számok: float – 4 bájton, 7 értékes számjegy double – 8 bájton, 15 értékes számjegy decimal – 16 bájton, 28 értékes számjegy
-
nullával való osztás egész számtípus esetén futás idejű hibát ad, míg valós számtípus használatakor nincs hiba; az eredmény: +-végtelen (poz/0, neg/0) vagy „nem szám” (0/0, végtelen/végtelen – float.NaN, double.NaN)
-
1
Ha nincs értékvesztés, a típuskonverzió egyszerű értékadással történik: Pl. byte a=2; int b=a; long c=3; float d=c; float f=1.2f; double g=f; Ha történhet értékvesztés, akkor jelezni kell a konverziót: típuskényszerítés (typecasting) – ez az explicit típuskonverzió célváltozó=(céltípus) forrásváltozó; Pl. int a=256; byte b=(byte)a; double c=1.23; int d=(int)c; int e=-1; uint f=(uint)e; Konvertálás striggé: célváltozó=forrásváltozó.ToString(); Pl. int a=310; string s=a.ToString(); Konvertálás stringből: célváltozó=céltípus.Parse(stringváltozó); Pl. string s=”210”; int a=int.Parse(s); 2
Konstansok -
Relációs (összehasonlító) operátorok
a const típusmódosító kulcsszó segítségével definiálhatjuk a program futása alatt megőrzik értéküket és nem lehet felüldefiniálni őket, illetve értékadó utasítással megváltoztatni az értéküket a konstans változóknak adott értéket vagy kifejezést fordítási időben ki kell tudja értékelni a fordító Pl. const int MAX = 100; // ha nem adunk értéket, hibát ad
== - egyenlő (a==b) != - nem egyenlő (a!=b) <, <= - kisebb, kisebb vagy egyenlő (a
, >= - nagyobb, nagyobb vagy egyenlő (a>b, a>=b) Logikai operátorok ! – tagadás: a kifejezés értéke „a” ellentettje (!a) && - ÉS: igaz, ha mindkét operandusa igaz (a&&b) || - VAGY: igaz, ha legalább az egyik operandusa igaz (a||b)
Kifejezések: -
a kifejezések operandusokból és operátorokból állnak az operandusok szolgáltatják az adatokat: változók vagy konkrét értékek, konstansok operátorok: műveleti jelek: +, -, *, / a kifejezések egymásba ágyazhatók, egy kifejezés operandusa maga is lehet kifejezés több operátor esetén az operátorok precedenciája határozza meg a kiértékelés sorrendjét a sorrend zárójelezéssel explicit módon is meghatározható operátorprecedencia: előjel-operátorok, logikai és bináris tagadás, prefix inkrementáló és dekrementáló operátorok, explicit típuskonverzió → szorzás, osztás, maradék →összeadás, kivonás →bitenkénti eltolás operátorok → kisebb (vagy egyenlő), nagyobb (vagy egyenlő), as, is → egyenlő, nem egyenlő →logikai ÉS →logikai XOR →logikai VAGY →feltételes ÉS →feltételes VAGY →feltételes operátor (? : ) →értékadó operátor és a rövidített formában használt operátorok (+=, -=, stb.)
Értékadó operátorok = (a=b) Rövid forma: += (a+=b ugyanaz, mint a=a+b), -=, *=, /=, %=, &=,^=, |=, <<=, >>= Kiíratás: -
Aritmetikai operátorok: + - egy operandus esetén előjelképzés (+a), két operandus esetén összeadás (a+b), stringek esetén összefűzés - - egy operandus esetén előjelképzés ( -a), két operandus esetén kivonás (a-b) * - szorzás (a*b) / - osztás (a/b) % - maradékképzés (a%b – pl. 5%3=2) ++ -inkrementáló operátor: növelés 1-gyel a++ - kiértékeli a kifejezést, majd utána növeli 1-gyel „a” értékét ++a - növeli 1-gyel „a” értékét, és a megnövelt értékkel kiértékeli a kifejezést -- - dekrementáló operátor: csökkentés 1-gyel a-- - kiértékeli a kifejezést, majd utána csökkenti 1-gyel „a” értékét --a - csökkenti 1-gyel „a” értékét, és a csökkentett értékkel kiértékeli a kifejezést
Beolvasás -
-
3
a C stílusú nyelvek hagyományaként a C# nyelvnek sem részei a beolvasó és kiíró utasítások, így könyvtári szolgáltatásokra kell hagyatkoznunk, ami a System névtér része és ennek a névtérnek a Console osztálya biztosítja a klasszikus képernyőre írás és olvasás feladatát Console.Write(“szöveg”) – kiírja a szöveget a standard outputra, azaz a képernyőn megjelenő Consol alkalmazás ablakába Console.WriteLine(“szöveg”) – kiírja a szöveget a konzolra és a kurzort a következő sor elejére viszi
Console.ReadLine() paranccsal: egy sort olvas be a standard bementről (alapértelmezés szerint a konzolról) A metódus egy string típusú értékkel tér vissza, ezért ha az s string típusú változóban szeretnénk eltárolni a beolvasott szöveget, akkor: string s = Console.ReadLine(); Ha a beolvasott értéket nem karaktersorozatként szeretnénk használni, akkor a szükséges konverziót is végre kell hajtani: típus.Parse(karaktersorozat) pl. int a = int.Parse(Console.ReadLine()) vagy Convert.ToTípus(karaktersorozat) pl. int a = Convert.ToInt32(Console.ReadLine()) 4
Ha egy feltételben több logikai kifejezést csatolunk össze ÉS / VAGY operátorokkal: - ÉS operátor esetén, ha az első kifejezés hamis, akkor a másodikkal már nem is foglalkozik, az eredmény mindenképp hamis lesz - VAGY operátor esetén, ha az első kifejezés igaz, akkor a másodikkal már nem is érdemes foglalkozni, az eredmény mindenképp igaz lesz
Vezérlési szerkezetek: Szekvencia - a legegyszerűbb vezérlési szerkezet, minden más vezérlési szerkezet építőköve - tulajdonképpen egymás után megszabott sorrendben végrehajtott utasításokból áll -
minden utasítást ; zár le az utasítások írhatók külön sorokba vagy egy sorba
Ciklusok ‐ C# -ban négyfajta ciklusutasítás használható, ezek a for, foreach, while és do utasítások A for ciklus (előírt lépésszámú, ún. számlálós ciklus)
Feltételes utasítás (elágazás, szelekció)
Az utasítás formája:
- megvizsgálunk egy állítást és az állítás igazságértékétől függően más-más utasítást hajt(hat)unk végre
for (kifejezés1; kifejezés2; kifejezés3) utasítás;
1. if (feltétel) utasítás1; [else utasítás2;]
ahol 1. kifejezés1: kezdőérték beállítása, típusdefiníciós kifejezés utasítás is lehet itt adjuk meg az ún. ciklusváltozót, amelyre a ciklusfeltétel épül pl. i = 0 – az i ciklusváltozó a for utasítás előtt deklarálva kell legyen pl. int j = 0 – a j int típusú ciklusváltozót a ciklus fejlécében hoztuk létre és adtunk 0 kezdőértéket neki; előtte nem lehet deklarálva a ciklusfeltételen belül deklarált ciklusváltozó lokális lesz a ciklust tartalmazó blokkra 2. kifejezés2: ismétlési feltétel (a ciklusban maradás feltétele) pl. i<10 – addig ismétli az utasítást, amíg i értéke kisebb, mint 10 (9-nél még elvégzi a ciklusmagot, 10-nél már nem) pl. i < n && k
- feltételben szereplő kifejezés minden esetben logikai értéket kell visszaadjon, vagy az eredmény konvertálható kell legyen bool típusra. - a feltétel teljesülése esetén végrehajtja az utasítás1-et, különben ha van else ág, akkor az utasítás2-t, ha nincs else ág, akkor a feltétel nem teljesülése esetén nem csinál semmit 2. if (feltétel) { utasítás1; utasítás2; } [else { utasítás3; utasítás4; }]
-
3. if (feltétel1) utasítás1; else if (feltétel2) utasítás2; else if (feltétel3) utasítás3; … … else utasításn;
‐ a C# a következőképpen értelmezi a for ciklust: 1. végrehajtja a kifejezés1-et (kezdőértékadás) 2. kiértékeli a kifejezés2-t (vezérlési feltétel): ha HAMIS, akkor kilép a ciklusból, ha IGAZ, akkor: 3. végrehajtja a ciklusmagot 4. végrehajtja a kifejezés3-at (léptetés) 5. visszaugrik a 2. lépésre
az else ág elhagyható több utasítás esetén kötelező a { } else if ágakból tetszőleges számú használható a program az első olyan ágat hajtja végre, amelynek a feltétele teljesül, vagy ha egyik feltétel sem teljesül és van else ág, akkor az ott levő utasítás(oka)t hajtja végre.
‐ előltesztelő ciklus, ha a vezérlési feltétel már legelső alkalommal HAMIS, akkor a ciklusmag egyetlen egyszer sem hajtódik végre ‐ a for ciklusból tetszés szerint elhagyhatjuk a ciklusfej bármely részét – akár az egészet is: ekkor végtelen ciklusunk lesz (soha nem ér véget)
5
6
pl. for (;;) { ...// valamilyen más módon lépünk ki ilyenkor a ciklusból } ‐ a kifejezések közötti pontosvessző nem maradhat el ‐ ha a for ciklus magja több utasítást tartalmaz, akkor az utasításokat {} közé tesszük (utasításblokk) ‐ a ciklusmag lehet üres utasítás is:
Kiértékelés: 1. végrehajtja a ciklusmagot 2. kiértékeli a zárójelben levő kifejezés-t (vezérlési feltétel): ha HAMIS, akkor kilép a ciklusból, ha IGAZ, akkor: 3. visszaugrik az 1. lépésre ‐ hátultesztelő ciklus, a ciklusmag végrehajtása után ellenőrzi a ciklusfeltételt, így legalább egyszer biztosan lefut
Ugró utasítások
A while ciklus
A break utasítás
- a while ciklus általános formája:
‐ az utasítás formája: break; ‐ hatására befejeződik a while, do while, for vagy switch utasítás végrehajtása
while (kifejezés) utasítás; a while kulcsszóval kezdődik a kifejezés a ciklusbanmaradás feltétele, logikai kifejezés kell legyen az utasítás a ciklus magja ha a a ciklus magját több utasítás alkotja, akkor {} közé tesszük és az utasításokat pontosvesszővel választjuk el egymástól Kiértékelés: 1. kiértékeli a zárójelben levő kifejezés-t (vezérlési feltétel): ha HAMIS, akkor kilép a ciklusból, ha IGAZ, akkor: 2. végrehajtja a ciklusmagot 3. visszaugrik az 1. lépésre ‐ akkor célszerű használni a while ciklust, ha nem tudjuk előre meghatározni az ismétlések számát (futás közben dől el), vagy ha a leállás valamilyen logikai értéket szolgáltató kifejezés eredményétől függ ‐ előltesztelős ciklus, a ciklusmag végrehajtása előtt ellenőrzi a ciklusfeltételt, előfordulhat, hogy a ciklustörzs egyszer sem fut le ‐ ‐ ‐ ‐
‐ a break a többirányú elágazás (switch) utasításban is gyakran használt A continue utasítás ‐ az utasítás formája: continue; ‐ hatására a while, for, do while ciklus feltételei kerülnek kiértékelésre ‐ a continue utáni rész teljesen kimarad az aktuális lefutáskor Véletlen számok generálása ‐ matematikai, statisztikai feladatoknál gyakran használunk véletlen számokat ‐ a System névtér Random osztálya nyújtja a pszeudo-véletlenszámok generálásának lehetőségét ‐ egy véletlenszám-objektum létrehozását a rendszeridőhöz (paraméter nélküli konstruktor) vagy egy adott egész számhoz köthetjük ‐ ha létrehozunk egy új, Random típusú változót, akkor ezen keresztül máris lehetőségünk van véletlenszerű számok elérésére ‐ a véletlenobjektum Next függvénye a következő véletlen egész számot, a NextDouble a következő valós véletlen számot adja ‐ a Next függvénynek három, míg a NextDouble függvénynek egy változata van
A do while ciklus - általános formája: do utasítás; // ciklusmag while (kifejezés) ; ‐ a do kulcsszóval kezdődik ‐ ha a ciklusmag több utasításból áll, akkor {} közé tesszük és az utasításokat pontosvesszővel választjuk el egymástól ‐ a kifejezés a ciklusban maradás feltétele, logikai kifejezés kell legyen 7
8
Példa: ‐ véletlenszám objektum létrehozása: Random r = new Random(); //r véletlenszám objektum rendszeridő alapú létrehozása Random r1 = new Random(10);// r1 véletlenobjektum generátor a 10 értékből indul ki
‐ a tömb definíciója egy referencia típus létrehozása, és a nyelv minden referencia típusát a new operátorral kell konkrét értékekkel példányosítani: ekkor kell megmondani, hogy az adott vektor hány elemű pl.
int[] x = new int[10]; // 10 x = new int[20]; // most
elemű egész tömb
…
‐ véletlen számok generálása:
már 20 elemű egész tömb, a régi tömbértékek
elvesznek
véletlen egész szám 0 és MaxInt (legnagyobb egész) között [0, MaxInt) int x = r.Next();
‐ mivel a nyelv minden dinamikus referencia típusának memóriabeli felszabadítását a rendszer automatikusan végzi –szemétgyűjtés (garbage collection) – ezért a példabeli 10 elemű tömb memóriahelyét automatikusan visszakapja az operációs rendszer ‐ a tömb elemei a fenti dinamikus létrehozás után 0 kezdőértéket kapnak ‐ ha logikai vektort definiálunk, akkor a vektorelemek kezdő értékadás hiányában logikai hamis (false) értéket kapnak
véletlen egész szám 0 és n között [0, n) int x = r.Next(n); int x = r.Next(10); // [0, 10) közötti véletlen egész számot generál
véletlen egész szám a és b között [a, b) int x = r.Next(a,b); int x = r.Next(10,20);//[10,20) közötti véletlen egész számot generál
Tömb inicializálása (akár a deklaráció pillanatában is feltölthetjük a tömböt a nekünk megfelelő értékekkel): pl. int[] b={1,2,3,4}; char[] c = new char[5] { 'e', 'd', 'a', 'c' , 'b' } vagy char[] c = new char[] { 'e', 'd', 'a', 'c' , 'b' } vagy char[] c = { 'e', 'd', 'a', 'c' , 'b' } // ha rögtön megadjuk a kezdőértékeket, a new operátor elhagyható
véletlen valós szám generálása 0 és 1 között [0, 1) double d = r.NextDouble();
Összetett adattípusok Tömbök
‐
‐
több, azonos típusú értéket tárol (van azonosítója: neve, típusa: az elemek közös típusa) az egyes elemek a tömbön belüli sorszámukkal (index) érhetők el egy elem értéke értékadással módosul egy elem értéke egy kifejezésben lekérdezhető háromféle tömb létezik: az egydimenziós (vektor), a többdimenziós (mátrix, kocka, stb.), illetve a szabálytalan (tömböket tartalmazó tömb, a „jagged”) tömb ‐ a tömbök referenciatípusok, így minden tömb deklaráció egy referencia (hivatkozás) a hozzá tartozó adatokra ‐ a referenciatípusú változók csak egy hivatkozást tárolnak a konkrét értékre ‐ az x = y értékadáskor az y ugyanazon a memóriacímen lévő értékre fog hivatkozni, mint az x ‐ a C# mindig folytonos memóriablokkokban helyezi el egy tömb elemeit ‐ a C# nyelv minden tömb- vagy vektortípus definíciót a System.Array osztályból származtat, így annak tulajdonságai a meghatározóak ‐ ‐ ‐ ‐ ‐
Tömbök deklarálása: típus [] azonosító; Tömbök létrehozása: a tömb méretének meghatározása pl. x = new int[10];
‐ ‐ ‐ ‐
A foreach ciklus ‐ az utasítás formája: foreach (azonosító in tömbnév) utasítás;
‐ a deklaráció és a tömblétrehozás összevonható: pl. int[] x = new int[10];
‐ ezzel a ciklussal végiglépdelünk egy tömbön vagy gyűjteményen ‐ az azonosító, mint ciklusváltozó felveszi egyenként a tömb elemeit
9
értékadás (érték elhelyezése a tömbelemben): x[0] = 2; a tömb egy adott eleméhez a tömb neve után [] zárójelek között megadott indexszel férhetünk hozzá: tömbnév[index] az index csak egész szám lehet, a típus tetszőleges a tömb első elemének indexe mindig: 0 a tömb utolsó elemének indexe: elemszám – 1 kisebb, vagy nagyobb index megadása futási hibát okoz tömbben lévő elemek száma a tömbnév.Length metódussal lekérdezhető a tömbelemeknek nem kötelező értéket adni, értékadás hiányában a tömbelem a típus alapértékét veszi fel a tömb elemein végiglépkedhetünk egy egyszerű for ciklussal, vagy használhatjuk a foreach ciklust vigyázat az indexeléssel, mert a fordító nem ellenőrzi fordítási időben az indexek helyességét, így helytelen indexelés esetén futás időben IndexOutOfRangeException kivételt fog dobni a program
10
stringazonosító.Equals(string) – megadja, hogy a paraméterként kapott szöveg azonos-e a stringazonosító karakterlánccal
Stringek
a string a System.String osztálynak megfelelő típus a string típus karakterekből áll, vagyis a karakterlánc egyes betűit char-ként kezelhetjük elméletileg bármennyi karakterből állhat, de az operációs rendszer határt szab számára a C# char (karakter) típusa egy unicode karaktert képes tárolni 2 bájton a stringek nem módosíthatók, módosítás helyett egy új példány jön létre
String.CompareOrdinal(string1, string2) – összehasonlítja a paraméterként kapott két stringet és az első különbözőségnél a két betű különbségét adja
Deklarálás: string azonosító; vagy String azonosító; Pl. string s;
stringazonosító.LastIndexOf(karakter vagy string) – a stringazonosító karakterláncban a paraméterként kapott karakter vagy string utolsó előfordulásának indexét adja vissza; -1, ha nincs találat
Deklarálás és inicializálás: string azonosító = “szöveg”; Pl. string s="alma";
Összefűzés: a + és a += szövegösszefűző operátorral
stringazonosító.IndexOfAny(karaktertömb) – a stringazonosító karakterláncban a paraméterként kapott karaktertömb összes karakterét figyeli, és amelyiket elsőnek megtalálja, annak indexét adja vissza; ha nincs találat, -1-et ad vissza
a string referenciatípus, de nem kell használni a new operátort ha egy stringnek nem adunk értéket, akkor induláskor ’null’ értéke van üres string: s = ""; vagy s = string.Empty; konstansként is használhajuk a stringeket: pl. const string sk="konstans szoveg"; amikor egy létező string objektum új értéket kap, akkor nem az eredeti példány módosul, hanem egy teljesen új objektum keletkezik a memóriában (vagyis a string megváltoztathatatlan típus, úgynevezett “immutable” típus) a string egyes karaktereire hivatkozhatunk a string azonosítója után [ ] között megadva az indexet (az indexelés 0-tól kezdődik) egy stringet feldolgozhatunk karakterenként egy for ciklussal a stringazonosító.Length – tulajdonság a szöveg karaktereinek számát adja meg a string utolsó karakterére való hivatkozás: stringazonosító[stringazonosító.Length-1] foreach ciklussal is végiglépkedhetünk egy karaktersorozaton
stringazonosító.LastIndexOfAny(karaktertömb) – a stringazonosító karakterláncban a paraméterként kapott karaktertömb összes karakterét figyeli, és amelyiket utolsónak találja meg, annak indexét adja vissza; -1, ha nincs találat
stringazonosító.Contains(karakter vagy string) - a stringazonosító karakterláncban keresi a paraméterként kapott karaktert vagy stringet, igaz-at ad vissza, ha megtalálja, különben hamisat Módosítás: ‐ a módosítások nem az eredeti stringen hajtódnak végre, hanem egy új példányt hoznak létre és azt adják vissza stringazonosító.Replace(regi_char_vagy_string, uj_char_vagy_string) - az első paraméterként kapott régi karakter vagy string összes előfordulását lecseréli a második paraméterként kapott új karakterre vagy sztringre
Relációk: két string összehasonlítható az == és a != operátorokkal a <, > relációk csak a string karaktereire alkalmazhatók a stringek hatékony kezeléséhez a .NET számos hasznos metódust biztosít
stringazonosító.Insert(index, karakterlánc) – beszúrja a stringbe a megadott karakterláncot a paraméterként kapott indextől kezdődően
Metódusok
stringazonosító.Remove(index, szám) – kivág a stringből a megadott indextől kezdődően megadott számú karaktert
Összehasonlítás: String.Compare(string1, string2) – összehasonlít két sztringet (lexikografikusan): eredményként 0-t ad, ha a két string megegyezik, illetve nullánál kisebbet (-1), ha az első string ábécésorrend szerint kisebb és nullánál nagyobbat (1), ha az első string nagyobb
stringazonosító.Substring(kezdőindex) vagy stringazonosító.Substring(kezdőindex, szám) – kimásol a stringből egy részt: ha a csak a kezdőindex van megadva paraméterként, akkor a kezdőindextől a string végéig; különben a kezdőindextől a megadott számú karakterből álló részt
összehasonlításra használhatjuk a stringazonosító.CompareTo(string1) metódust is
stringazonosító.Trim() – a string elején és végén levő “fehér” karaktereket vágja le (space, tab)
11
Keresés: stringazonosító.IndexOf(karakter vagy string) – a stringazonosító karakterláncban a paraméterként kapott karakter vagy string első előfordulásának indexét adja vissza; ha nincs találat, -1-et ad vissza
12
o StringBuilder típus konvertálása string típusra a ToString() Pl. StringBuilder s = new StringBuilder();
stringazonosító.TrimStart() – a szöveg elejéről vágja le a szóközöket
s.Append("alma"); string z = s.ToString();
stringazonosító.TrimEnd() – a szöveg végéről vágja le a szóközöket stringazonosító.TrimStart(karakter) – a szöveg elejéről vágja le a paraméterként kapott karakter összes előfordulását stringazonosító.TrimEnd(karakter) – a szöveg végéről vágja le a paraméterként kapott karakter összes előfordulását stringazonosító.Trim (karakter) – a szöveg elejéről és a végéről vágja le a paraméterként kapott karakter összes előfordulását stringazonosító.Trim(karaktertömb) – a string elején és végén levő, a paraméterként kapott karaktertömbben szereplő karaktereit vágja le
stringazonosító.ToUpper() – nagybetűssé alakítja a stringet
az AppendLine() metódussal sortörés fűzhető egy stringBuilder típusú változóhoz
Többdimenziós tömbök Kétdimenziós tömb (mátrix) deklarációja: típus [,] azonosító; // a két indexet úgy jelezzük, hogy egy vesszőt teszünk a zárójelbe pl. int [,] x; string [,] nevek;
Többdimenziós tömb esetén: szögletes zárójelbe (dimenziószám - 1) vesszőt teszünk - pl. háromdimenziós tömb deklarálása: típus [,,] azonosító;
Példányosítás: megadjuk az egyes indexekhez tartozó elemszámot azonosító = new típus [a, b] ;
stringazonosító.ToLower() – kisbetűssé alakítja a stringet
// „a” darab sor, „b” darab oszlop
pl. x = new int [5, 5] ; // 5x5-ös, egészekből álló mátrix nevek= new string[2,3]; // 2 soros, 3 oszlopos, stringekből álló mátrix
stringazonosító.Split(char típusú elemeket tároló tömb vagy egy karakter) – a string felbontása több stringre: a paraméterként kapott tömb karakterei mentén darabolja fel az adott stringet, eredményként egy stringeket tároló tömböt ad vissza; a paraméterül megadott karakterek nem lesznek benne a kapott tömb egyik elemében sem
‐ a kétdimenziós tömböt feltölthetjük kezdőértékkel, hasonlóan az egydimenziós esethez: pl. int[,] x = new int[5, 5] {{1,2,3,4,5}, {6,7,8,9,10}, {11,12,13,14,15},
StringBuilder o a StringBuilder osztállyal módosítható szöveget hozhatunk létre o a StringBuilder a System.Text névtérben található o ha sokszor van szükségünk a karakterlánc módosítására és azt szeretnénk elérni, hogy az eredeti szövegünk is változzon, akkor használjuk a StringBuilder típust o a StringBuilder automatikusan lefoglal egy nagyobb darab memóriát, és ha ez sem elég, akkor kijelöl egy megfelelő méretű területet és átmásolja magát oda o ha a konstruktornak nem adunk meg paramétert, akkor alapértelmezés szerint 16 karakternek foglal le helyet a memóriában; de megadhatjuk paraméterként, hogy hány karakternek foglaljon le helyet o az Append metódussal tudunk egy vagy több karaktert vagy akár string típusú változót hozzáfűzni a StringBuilder típusú változó egyes részeit ki lehet cserélni Pl. s.Append("mara");
{16,17,18,19,20}, {21,22,23,24,25}}; // a new int[5, 5] elhagyható
‐ többdimenziós tömb elemeire úgy hivatkozunk, hogy a tömb neve után [] között annyi indexet adunk meg, ahány dimenziója van a tömbnek ‐ kétdimenziós tömb elemeire való hivatkozás: azonosító [sorindex, oszlopindex] ‐ az indexek itt is 0-tól kezdődnek pl. az x mátrix második sorbeli, harmadik oszlopbeli elemére való hivatkozás: x[1,2] ‐ kétdimenziós tömb feltöltése elemekkel: 2 egymásba ágyazott for ciklussal oldható meg, ahol az egyik ciklusváltozó az egyik indextartományt, a másik ciklusváltozó a másik indextartományt futja végig ‐ ha nem két, hanem többdimenziós tömböt használunk, akkor az egymásba ágyazott ciklusok száma ennek megfelelő ‐ az egyes dimenziókbeli méretet a GetLength metódus adja pl. int[,] x = new int[5, 4];
s[1] = 'á'; // s="mára"
o a módosítási metódusok az eredeti szövegen hajtódnak végre Pl. StringBuilder s = new StringBuilder(10);
int y = x.GetLength(0); // y = 5 int z = x.GetLength(1); // z = 4
s.Append("ki23csikutya"); s.Remove(2, 2); // s=kicsikutya
o a string típus StringBuilder típussá való konvertálása automatikus (az Append metódussal történik 13
14
