C# programozás - 2. lecke: Változók és típusok
Bevezetés
Nagyon örülök, hogy sokaknak tetszett az elso lecke, és jelezték, hogy érdemes lenne folytatni. Remélem ez a rész is érthető és hasznos lesz. Ezúttal is várom a fórumban az észrevételeket.
Szükséges eszközök:
A cikkhez Visual Studio-ban készítem a példákat, ajánlott a feltelepítése, ha valaki követni szeretné a lecke gyakorlatát. Többen felhívták a figyelmemet egy alternatívára is: SharpDevelop. Mivel nem szeretnék semmi jónak elrontója lenni 
ezt is ki lehet próbálni, bár én nem ismerem. Első futtatásra szimpatikus, kis méretű, gyors és hasonlít a Studio-ra, autocomplete is működik. Ingyenes, letölthető innen.
Témakör:
Ez a rész talán a legalapvetobb programozási muveletekrol szól: egyszeru adatok kezelése. A számítógépek gyakorlatilag mást sem tesznek, mint adatokat olvasnak, írnak és muveleteket hajtanak végre rajtuk. Megnézzük, hogy C#-ban milyen eszközök állnak rendelkezésünkre ehhez. Akit bővebben érdekel a számábrázolás háttere, az a lecke végén olvashat róla. A lecke megkezdéséhez hozzunk létre egy új Visual C# Console Application-t. Én a Variables nevet adtam a projektnek, ami a "Változók" szó angol megfelelője.
Típusok
C#-ban, ha adatot szeretnénk tárolni, akkor meg kell határoznunk a tárolni kívánt adat típusát. A nyelv 15 beépített típussal rendelkezik, ezekből válogathatunk annak megfelelően, hogy melyik a legcélszerűbb számunkra. Ahogy a garázsban autót, az iskolatáskában könyvet, füzetet, a pénztárcában pénzt tartunk, ahhoz lehet hasonlítani a programozási nyelvben ezeket a tárolótípusokat.
Megjegyzés: A ^ jelet a hatványozás jeleként használom. 3^2 az 3*3=9.
Egész számok:
Ha egész számokra van szükségünk, akkor 9 különböző tárolótípus áll rendelkezésünkre.
byte: 1 bájt méretű, 0-tól 255-ig tárolhatunk benne számokat, azaz 256 különböző értéke lehet.
sbyte: 1 bájt méretű. Signed byte rövidítése, azaz előjeles bájt, -128-tól +127-ig tárolhat számokat.
ushort: 2 bájt, 0-tól 2^16 - 1-ig (65535) terjed. Az unsigned integer, azaz "előjel nélküli egész" szó rövidítése.
short: 2 bájt, -32768-től 32767-ig.
uint: 4 bájt, 0-tól 2^32 - 1-ig tárolhat számokat.
int: 4 bájt, -2milliárd és +2milliárd közötti érték lehet, pontosabban -2^32 és 2^32 - 1.
ulong: 8 bájt, 64 bit, azaz elég nagy számok elférnek benne. 0-tól 2^64 - 1.
long: az ulong előjeles változata.
char: A kilencedik típus speciális, mert 16 bites tároló, (unicode) karakterek tárolására használatos, de részben számnak is tekinthetjük, mint ahogy a Visual Studio Help-je is teszi. Ennek ellenére nem biztos, hogy célszerű.
Lebegőpontos számok:
A cikk végén kitérek az elnevezésre, ha valaki kíváncsi rá megtudhatja mit jelent, de most elég az, hogy nem egész számok tárolására használjuk.
float: 32 bites szám, ±1.5 × 10^−45 től ±3.4 × 10^38-ig képes számot tárolni, és ami fontos 7 tizedesjegy pontossággal. A lebegőpontos számok nem minden törtet képesek ábrázolni, mert 32 biten csak néhány számjegyet lehet tárolni pontosan. A tartományt így lehet értelmezni: -3,4x10^38 a legkisebb érték, +3,4x10^38 a legnagyobb érték, amit felvehet. A legkisebb pozitív szám, amit tárolhat 1,5x10^-45, a legnagyobb negatív - 0-hoz legközelebbi - pedig a -1.5x10^-45.
double: 64 bites, úgynevezett dupla pontosságú típus. Ez hasonló a float-hoz, gyakorlatilag a kiterjesztése. 15-16 számjegy pontossággal adhatjuk meg az értékeket, és 10^-324, valamint 10^308 nagyságrendű lehet.
Szöveg tárolása:
Karakterek, azaz 1 betű tárolására a már említett char, szövegek - több karakter - tárolására a string típus használható. Ezeket példán keresztül fogjuk megvizsgálni, talán most nem érdemes jobban belemélyedni. Ha az objektumokról lesz szó későbbi leckében, ott a string-ről érdemes néhány szót ejteni.
Igaz, hamis értékek
Ha van egy programunk, gyakran előfordul, hogy meg kell vizsgálni bizonyos feltételeket. A felhasználó be van-e jelentkezve? Az érdemjegy nagyobb-e 1-nél? Erre külön típus van, a bool.
bool: Két értéke lehet, igaz, vagy hamis, amiknek a true és a false szavak a megfelelői.
object és decimal
Ez a két beépített típus maradt még ki. Az object-ről az "Osztályok, objektumok" leendő témakörben lesz szó.
decimal: Részletesen ezzel sem foglalkozunk, speciális adattípus, pénzügyi számításoknál jól használható.
Változók
Most, hogy ismerjük az alapvető típusokat, elkezdhetjük használni. Mi is az a változó? wikipedia: A számítógép-tudományban és a matematikában a változó egy mennyiség vagy egy objektum szimbolikus jelölése.
Ha például szeretnék egy számot használni és eltárolni, amit a felhasználó megad a programomnak, akkor először meghatározom a megfelelő típust, azután megadom a programnak, hogy szeretném, ha a memóriában lenne hely, ahol eltárolhatom, és adok neki egy nevet, amivel hivatkozhatok rá.
Nézzünk egy példát: írjuk át az új, üres projektünket, hogy ez szerepeljen benne:
using System;
namespace Variables
{
class Program
{
static void Main(string[] args)
{
int eletkor; // Megadom a tipusát és a nevét
eletkor = 25; // Erteket adok a számnak
Console.WriteLine(eletkor);
Console.ReadKey();
}
}
}
Az előző leckéből tudhatjuk, hogy a Main függvénynél kezdődik a program végrehajtása, a nyitó { jel után.
int eletkor;
Ebben a sorban megadom a változóm típusát, ami int, és megadom a nevét, 'eletkor'. Az utasításom után a // jeleket írtam, ez arra használható, hogy megjegyzéseket tegyünk. Ami a // után következik, azt a fordító figyelmen kívül hagyja. Ez jó, ha később szeretnénk elolvasni mit csinál a program, vagy másnak odaadjuk, és segít neki a megértésben.
eletkor = 25;
Most egy nagyon fontos fogalom következik, az értékadás. Bal oldalon szerepel a változónk, amibe egy számot szeretnénk elhelyezni, jobb oldalon pedig a kívánt érték szerepel. Az egyenlőségjel nem ugyanaz, mint amit matematikából megszokhattunk! Nem azt jelenti, hogy az 'életkor' az 25. Azt fejezi ki az = jel, hogy a bal oldalon található változó értéke ezentúl 25 legyen. Ezt nevezzük értékadásnak.
Console.WriteLine(eletkor);
A Console.WriteLine már szerepelt az előző leckében, a zárójelek közti részt írja ki. Fontos, hogy nem azt fogja kiírni a képernyőre, hogy "eletkor", hanem az értéket, amit az 'eletkor' változóban tároltunk.
Végül a programunk vár egy billentyűleütést, és kilép.
Bővítsük ki egy kicsit a programunkat! Mielőtt lefuttatjuk érdemes kitalálni, vajon mit fog kiírni.
using System;
namespace Variables
{
class Program
{
static void Main(string[] args)
{
int eletkor; // Megadom a tipusát és a nevét
eletkor = 25; // Erteket adok a számnak
Console.WriteLine(eletkor);
eletkor = 13;
Console.WriteLine(eletkor);
Console.ReadKey();
}
}
}
Változók létrehozása, és értékadás - részletesebben
Most, hogy van mihez viszonyítani megvizsgáljuk részletesebben a lehetőségeket.
Változók neve:
A változó nevének megadásakor elég nagy szabadságot kapunk. A névnek betűvel, vagy _ (alulvonás) karakterrel kell kezdődnie, és használhatjuk az ABC összes betűjét, és számokat is.
Érvényes elnevezések:
eletkor
_eletkor
életkor
elet_kor
eletkor123
x
O
á
console
system
Nem ajánlott:
életkor - szabad ékezetes betűket használni, de nem szokás. Ahol nem használnak ékezetes betűket, oda is eljuthat a kódunk.
O - érdemes úgy elnevezni, hogy "beszédes" legyen a változónév. Meg ez o betű vagy nulla?
system - megtévesztő, a System névtérhez túl hasonló
Nem lehet:
double - ez a C# egy beépített szava
private - szintén, ami kék lesz a szerkesztőben az nem fog menni.
System - a System névtér neve
Program - a programunk egy összetett típusa, osztálynév.
123labda - nem kezdődhet számmal
valtozo:) - speciális karakterek sem lehetnek benne
Változók létrehozása:
Típus megadása, szóköz és változónév. Az utasítás végére pedig ;-t teszünk. Egyesével hozzuk létre a változókat.
int x;
int y;
double tortresz;
float f;
Vesszővel elválasztva is felsorolhatjuk a neveket, ha ugyanabból a típusból többre is szükségünk van.
int x, y, z; // koordinatak
double tortresz, hanyados;
Amikor megadjuk a változó nevét, egyből értéket is adhatunk.
int x = 1;
int y = 2;
A módszereket kombinálhatjuk is. Több változót hozunk létre, és amelyiknek szeretnénk közben értéket adunk.
int x, y = 3, z;
Nem csak a program elején vezethetünk be változóneveket:
static void Main(string[] args)
{
int elsovaltozo = 5;
Console.WriteLine(elsovaltozo);
int masodikvaltozo = 3;
}
Értékadás:
A változóknak már tudunk egész értéket adni, de van néhány szabály, amit be kell tartani. A megfelelő típusnak megfelelő értéket adhatunk csak. Máshogy lehet megadni a szöveget, karakter, egész számot, törtszámot.
Egész értékek:
Ha egy változó a típusa szerint csak egész értékeket tárolhat, akkor csak azt adhatunk értékül. Arra is ügyelni kell, hogy ne legyen túl nagy, vagy túl kicsi. Ha negatív értéket szeretnénk megadni, akkor egy - jelet írunk a szám elé.
byte kisszam;
kisszam = 0; // ennel kisebb nem lehet
kisszam = 255; // ennel nagyobb nem lehet
kisszam = +255; // nem valtozik az erteke, ha nincs - jel, akkor pozitiv a szam
sbyte elojeleskisszam = -5; // lehet pozitiv is, es negativ is
elojeleskisszam = 3;
long nagyszam = -2100500300335;
Ami hibát okoz:
byte b = -1; // nemnegativ kell legyen
sbyte sb = -255; // tul kicsi
int szam = 2100500300335; // tul nagy
Ha a fenti sorokat begépeljük a programunkba, akkor a számok piros hullámos vonallal alá lesznek húzva, mert a rendszer képes ellenőrizni, és figyelmeztet, hogy nem megengedett értékadás.
Lebegőpontos számok:
Nem egész számok esetén tágabbak a lehetőségeink. Két típusunk van, a float, és double, használatuk nagyon hasonló. Először vegyük a double használatát!
Az egész számok esetén látott értékadásokat alkalmazhatjuk lebegőpontos számoknál is:
Megjegyzés: az 1, 2, -3 a példában egész szám, és "1.0", "2.0", "-3.0" törtszámokká alakul
double egy = 1, ketto = 2, minuszharom = -3;
Ha nem egész számot szeretnénk megadni, akkor a tizedesjel a . elé az egészrészt, mögé a törtrészt adhatjuk meg:
double masfel = 1.5, egyketted = 0.5, pi = 3.14, negativ = -0.997;
Ha az egészrész 0, akkor a pont elől elhagyhatjuk:
double dKisszam = .067;
double dNegativKisszam = -.025;
Néha kényelmesebb lehet megadni, vagy leolvasni a számokat úgy, hogy megadjuk a tizedesjegyeket (a legfeljebb 16-17 számjegyet, amilyen pontosan számolhatunk double típussal), és 10 egy megfelelő hatványkitevőjét, amire 10-et emelve szorozzuk a számot.
Hogy könnyebb legyen elképzelni:
double avogadro = 6.022e23;
double massofelectron = 9.10938188e-31;
Az Avogadro szám körülbelül 6,022x10^23, ami: 602200000000000000000000. Látszik, hogy a fenti jelölés szemléletesebb, az elektron tömegénél méginkább.
float számok megadása: Legegszerűbb, ha mindenhol úgy használjuk, mint a double-t, csak a számok után teszünk egy "f"-et.
float Pi = 3.14f;
float minuse = -2.71828183f;
float bignumber = 1e20f;
Ez azért kell, mert a kódunkban megadott lebegőpontos számokat a precízebb double-ként értelmezi a fordító, ha float-ként szeretnénk kezelni, akkor azt külön jelezni kell.
Azt vegyük figyelembe float használatakor, hogy kisebb számot tárolhat, mint a double, és a pontossága is körülbelül fele a double 15-16 számjegyének.
Karakterek:
C#-ban 16 bites Unicode karaktereket tárolhatunk char típusú változóban. A karakterek/betűk megadásának többféle módja van:
char xBetu = 'x'; // ' ' jelek kozott
char nagy_aBetu = (char)65; // 'A' kodja 65, 10-es szamrendszerben megadva
char nagy_bBetu = '\u0042'; // \u utan a 'B' kodja, ami 66, 16-os szamrendszerben 42
char nagy_cBetu = '\x0043'; // itt is 16-os szamrednszerben kell megadni a kodot
char cmin = '\x0000'; // a char legkisebb erteke
char cmax = '\xFFFF'; // a char lehetseges legnagyobb erteke
Az egyszerűsége miatt az első módszert ajánlom hagyományos karakterekhez. Ha valami speciálisabb karaktert szeretnénk tárolni, akkor a másik három módszerrel a kódjának megadása alapján.
Szövegek, karakterláncok tárolása:
Szövegeket string típusú változókban tárolhatunk. A szöveget " " jelek között kell megadni. Az első leckében lévő Console.WriteLine() függvénynek is string-et adtunk meg, amikor beírtuk a "Hello World"-öt.
string szoveg = "Első string változóm!";
A stringeknél fontos tárgyalni az úgynevezett escape character használatát. Felmerülhet a kérdés, hogy ha a " " jelek közötti rész kerül kiírásra, akkor hogyan írom ki a " jelet? A \ jelet nevezzük escape character-nek, ha ezt írjuk egy szövegbe, akkor az utána következő részt speciálisan kezeli a nyelv. Az említett " jel kiírása:
Console.WriteLine("\" - sikerült!");
Normál esetben a kezdő " után a következő " jel lezárta volna a szöveget, de az előtte lévő \ jel miatt nem ez történik. Ezután kérdezhetnénk azt is, hogyan írjuk ki a \ jelet?
Console.WriteLine("\\ - sikerült!");
Itt a trükk, a \ jel utáni \ jel kiírásra kerül.
Van néhány speciális, \ után gyakran használt karakter:
// \n ujsor
string ketsor = "Elso sor\nMasodik sor";
Console.WriteLine(ketsor);
// \t TAB
string tabok = "Tabokat hasznalunk:\t1\t2\t345\t67\t8";
Console.WriteLine(tabok);
Logikai értékek kezelése:
A logikai értékek, az igaz és hamis tárolása nagyon egyszerű.
bool igaz = true;
bool hamis = false;
Műveletek változókkal
Alapműveletek (+ - * /)
Alapműveletek egész számokkal: Nézzük egy példán keresztül!
int x = 4, y = 3;
int osszeg, kulonbseg, szorzat, hanyados, maradek;
osszeg = x + y;
kulonbseg = x - y;
szorzat = x * y;
hanyados = x / y;
maradek = x % y;
Console.WriteLine(osszeg);
Console.WriteLine(kulonbseg);
Console.WriteLine(szorzat);
Console.WriteLine(hanyados);
Az eredmény többnyire egyértelműen látszik, kivéve az osztást. Mivel a hányados egész szám, és az x, y is egész szám, ezért sehol nem lesz lebegőpontos számunk. A hányados, ami 4/3 ezért nem 1,3333... lesz, hanem 1. Ilyen esetben a szám egészrésze lesz az eredmény, még akkor is, ha például 1,999 lenne az eredmény.
Egész számoknál még figyelni kell, hogy ne lépjük túl az egyes típusok legnagyobb és legkisebb lehetséges értékét. Úgy általában számoknál figyelni kell, hogy 0-val ne osszunk.
Még egy speciális művelet van a fenti kódban, a %: Ez arra jó, hogy "a % b" esetén a-t osszuk el b-vel, és a művelet eredménye legyen a maradék.
Művelek lebegőpontos számokkal:
Hasonlóan történik az egész számokhoz. Az osztás viszont nem csak az egészrészt fogja visszaadni, hanem az osztás tényleges eredményét - float/double pontosságnak megfelelően.
Műveletek string-ekkel
A stringek esetén egyetlen fontos művelet van, amit most érdemes tárgyalnunk, az úgynevezett konkatenáció. Ez a szó gyakorlatilag azt jelenti, hogy string-eket egybeírhatunk.
string elso = "Elso fele";
string masodik = "Masodik fele";
string mindketto;
mindketto = elso + masodik; // eredmeny: "Elso feleMasodik fele" lesz a mindketto erteke
Műveletek logikai értékekkel:
Az igaz ellentettje a hamis és fordítva. Tehát az "igaz" az "nem hamis" és a "nem igaz" az hamis. A logikai értékek megváltoztatásához a negálást/tagadást lehet használni:
bool igaz = true;
bool nemigaz;
nemigaz = !igaz; // A ! jellel lehet tagadast kifejezni
Feladatok:
Találjuk ki, melyik sor helyes, és melyik nem:
static void Main(string[] args)
{
int elso;
int masodik;
int 3adik;
int n4egyedik;
elso = 1.0;
masodik = 2;
float floatValtozo = 4.5;
double masikValtozo = 4;
}
Kis segítség: Miután kitaláltuk Visual Studio-ban lehet ellenőrizni. Aláhúzza pirossal a hibás sorokat.
Az indoklásunkat is lehet ellenőrizni, mert az egeret a piros rész felett tartva kiírja a hiba okát.
int x = 7, y = 4, eredmeny, masik_eredmeny, harmadik;
eredmeny = x*y;
harmadik = x * masik_eredmeny;
masik_eredmeny = x / y;
harmadik = x * masik_eredmeny;
Console.WriteLine(eredmeny);
Console.WriteLine(masik_eredmeny);
Console.WriteLine(harmadik);
Console.ReadKey();
Melyik a hibás sor? Ha elhagyjuk, megtudjuk mondani kiírás előtt az egyes eredményektet?
Kiegészítések
A számábrázolással és egyéb kiegészítű részekkel kapcsolatos anyagok idő szűkében még nem jelennek meg, pótlás érkezik...
