Változók és típusok

Változók

Változók programozási elemek, amiket szabadon hozhatunk létre kódunk írása közben.

Egy változóra tekintsünk úgy mint egy tárolóra, amibe valami adatot, értéket tudunk beletenni, majd később visszaolvasni.

Amikor létrehozunk egy változót, adunk neki egy nevet vagy más néven azonosítót. A későbbiekben ezzel az azonosítóval fogunk tudni hivatkozni a változóra és ezáltal a benne tárol értékre.

Az, hogy a változó milyen értékeket vehet fel, a változó típusa határozza meg. Például, ha egy változó egész szám típusú, akkor az értékei lehetnek 0, 1, 2, 3… és ugyanígy -1, -2, -3… és így tovább a teljes számegyenesen. Másik példa lehet egy szöveg típusú változó ami, bármilyen szöveges értéket vehet fel.

Egy változónak (ahogy a neve is sugallja) meg tud változni az értéke. Új adatot tud a változóba tenni a programozó.

Szóval a változót 3 információ ír le.

• Azonosító: Mi a változó neve, hogyan hivatkozunk rá a későbbiekben.
• Típus: Milyen típusú értékeket tartalmazhat
• Érték: Egy aktuális (típusnak megfelelő) érték, adat. Információ, amit tárolunk a változóban

Példa

Hogy megértsük a változókat, képzeljük el a következő valós élet béli szituációt:

Tegyük fel, hogy egy zöldség- és gyümölcsraktárban dolgozunk. A raktárba folyamatosan hozzák és viszik az árut. A feladatunk az, hogy minden nap végén leadjunk egy listát arról, hogy mennyivel változott a raktár állománya bármely zöldségből, gyümölcsből. Szerencsére minden szállító köteles nekünk lejelenteni, mit vitt el és mit hozott be.

Egyelőre felejtsd el azt, hogy most programozásról van szó. Hogy oldanád meg ezt a feladatot, a valóságban a legkevesebb munkával? Nincs a kérdésben semmi beugrató, egyszerűen józan paraszti ésszel kell hozzáállni. Szánj rá egy percet, hogy végig gondold!

Az én megoldásom a következő lenne:

Minden reggel előveszek egy papírt és felírom rá az árucikkeket sorban és minden sor mögé írok egy nullát. Ez a szám azt jelenti, hogy mennyit változott a mennyiség az adott napon. Ha az érték változik, akkor az előzőt áthúzom vagy kiradírozom és felírom az újat. Tehát…

• Ha behoztak például 3 zsák krumplit, akkor a “Krumpli” sor értéket növelem hárommal.
• Ha elvisznek 5 karton banánt, a “Banán” sor értékét csökkenem öttel.

Amit itt csináltunk az programozói módon úgy fogalmazhatnánk meg, hogy felvettünk néhány egész szám típusú változót, amiket olyan nevekkel vagy azonosítókkal láttunk el, mint Krumpli és Banán reprezentálva a névvel azt, hogy milyen adatot tartalmaznak. A változóknak adtunk egy kezdőértéket, mikor létrehoztuk őket, ám ezt az értéket később akár többször változtattuk. Innen a név: változó.

Hogy hozunk létre és módosítunk változókat C# kódban?

int potatoCount = 0;		// Létrehozunk egy potatoCount nevű változót és
												// 0 kezdőértéket adunk neki.
												// A változó típusa: int (azt jelenti, egész szám)

int bananaCount = 10;   // Létrehozunk egy potatoCount nevű változót is 
												// 10-es kezdőértékkel

potatoCount = potatoCount + 3;		// potatoCount értékét növeljük 3-mal.
bananaCount = bananaCount - 5;		// bananaCount értékét csökkentjük 5-tel.

Figyeljük meg, hogy minden sort pontosvesszővel zártunk! (Leszámítva a sor végi kommenteket)

Ez egy szintaktikai szabály: Minden utasítás után pontosvesszőt kell tennünk. Az, hogy minden utasítást külön sorba teszünk nem szintaktikai szabály mégis nagyon erősen javasolt. Ellenkező esetben a kódunk nagyon hamar olvashatatlan lesz.

Vegyünk most még egy példát!

Képzeljük el, hogy a raktár igazgatójától kapunk egy új feladatot. Kíváncsi arra, melyik beszállítója dolgozik a legtovább. A mi dolgunk ezért az is, hogy írjuk fel minden nap, hogy ki az utolsó szállító, aki hoz vagy visz bármi árut.

Hogy oldjuk ezt meg? Gondold végig!

Mivel nem tudjuk, hány szállítmány jön egy nap, és mikor jön az utolsó, nem elég csak a nap végén figyelni. Nap elején felírjuk, egy új sorban, hogy utolsó szállító, és amint érkezik valaki felírjuk a nevét. Minden alkalommal, amikor új ember érkezik, töröljük az előző nevet és felírjuk helyette az újat.

Ezt így programoznánk le:

string utolsó;	    // Létrehozunk egy utolsó nevű változót
			              // A változó típusa: sting (azt jelenti, szöveg)
utolsó = "Smith";	  // Adunk a változónknak egy kezdőértéket
			              // Ezúttal külön sorban is tesszük a létrehozástól. 
utolsó = "Jones";	  // Teljesen új értéket kap a változónk. 
utolsó = "Wilson";	// Teljesen új értéket kap a változónk. 
utolsó = "Taylor";	// Teljesen új értéket kap a változónk.

Az azonosító

A változók nevét mi adjuk meg. (Majd látni fogjuk, hogy ez sok más programozói elemre is igy lesz.)

Típusok

A változó típusa határozza meg, milyen értékeket vehet fel.

Ezek mindegyike C# beépített vagy primitív típus.

A változó egy “adag” adatot reprezentál. Ez az adat lehet egyszerűbb és bonyolultabb is. A programozás legegyszerűbb adatai a primitívek.

C# mint statikusan típusos nyelv

Egy változó típusa C#-ban nem változhat meg deklaráció után.

A C# újabb verziói támogatnak dinamikus típusokat, de ezzel, most ne foglalkozzunk!

Deklaráció és Definíció

Deklaráció: Ahhoz hogy használni tudjuk először is létre kell hozni vagy más néven deklarálni a változót, ekkor adunk neki típust és nevet.

int testVariable;

// Egy sorban több azonos típusú változót is deklarálhatunk:
int x, y, z;

Definíció: Mielőtt használni tudjuk a deklarált változónkat kell neki egy kezdőértéket adni.

testVariable = 5;

// Deklaráció és definíció egy sorban is szerepelhet:
int otherTestVariable = 34;

// Egy sorban több azonos típusú változót is deklarálhatunk és definiálhatunk:
int i = 1, j = 2, k = 3;

Definíció után a változó értékét bármikor kiolvashatjuk és felhasználhatjuk valamire.

 // Kiírjuk a változó értékét:
Console.WriteLine(testVariable);     // Parancssori alkalmazásban
Debug.Log(testVariable );            // Unity szoftverben

Definíció után a változó értékét bármikor módosíthatjuk.

testVariable = 67;                 // A változó értékét átállítom 67-re.
testVariable = testVariable + 4;   // A változó értékét növeltom 4-gyel.

A var kulcsszó

Ha egy sorban deklarálunk és definiálunk egy változót, akkor a típus kiírása elhagyható, hiszen ebben az esetben akár a fordítóprogram is kitalálhatja a típust az érték alapján. Ekkor a típus neve helyett a var kulcsszót használhatjuk:

var variableA = 5;                // Az érték egész szám, szóval a változó int típusú
var variableB = "Valami szöveg";  // Az érték szöveg, szóval a változó string típusú

var variableA;               // ⛔ERROR⛔ 
variableA = "Valami érték";  // Ez így nem fog működni

string variableB;            // ✅Helyes✅ 
variableA = "Valami érték";  // Ha külön sorban definiálunk, nem hagyhatjuk el a típust.

Ez nem azt jelenti, hogy a változónak nincsen típusa, vagy dinamikus a típusa, csak azt, hogy nem kellett azt leírni. Más szavakkal, a változó nem fog tudni típus váltani.

var abc = "Valami érték";  // abc változó sztring típusú
abc = 2.4f;                // ⛔ERROR⛔  float értéket adnánk egy string változónak

A var kulcsszó pusztán csak arra való, hogy megspóroljuk a típus kiírását. Ennek az olyan egyszerű primitív típusok esetén mint az int vagy string nem túl sok értelme van. Javaslom, hogy egyelőre ne szokjunk rá!

Beolvasás konzolról

Erre parancssori applikáció írásakor lehet szükség. Unity-ben sosem.

Konzolról szöveges információt beolvasni a Console.ReadLine() paranccsal tudunk.

Ezután ezt átalakíthatjuk az adott szöveget egyéb adatokká a <típus>.Parse(string text) paranccsal.

string line = Console.ReadLine();

int integerNumber = int.Parse(line);
bool logicalValue = bool.Parse(line);
float floatingPointNumber = float.Parse(line);

Ha az átalakítás nem lehetséges az futási idejű error-t eredményez. A program futása leáll.