C# Puska 1 - Beépített típusok

/* Ez egy rövid szeparált komment. */

/* Vele egy sorban elé és mögé is kerülhet hasznos kód. */

/*
Ez egy több soros komment.
Még mindig tart.
Addig fog is, amíg le nem zárom a csillag+per karakterekkel.
*/

// Ez egy sor végi komment.
// Hatása a sor végéig tart.
// Vele egy sorban csak előtte szerepelhet hasznos kód.

// Változók
int i = 4;                      // Egész szám
float f = 5.3f;                 // Tört szám  (ki kell írni az f-et a végére)
string s = "Some text";         // Szöveg
bool b = true;                  // Logikai érték

// Minden utasítás végére pontosvesszőt kell tenni

// Változók műveletei:
int myFirstVariable;            // Változó deklarálása: Létrehozása
                                // Ha egy változót deklarálunk, adunk neki:
                                //    - Típust
                                //    - Azonosítót (nevet)

myFirstVariable = 5;            // Változó definiálása: Kezdeti értékadás
                                // Ha egy változót definiálunk, adunk neki:
                                //    - Értéket

int mySecondVariable = 3;       // Változó deklarálása és definílása egy sorban
myFirstVariable = 5;            // Változó értékének módosítása
myFirstVariable = mySecondVariable;    // Változó értékének módosítása
int aaa, bbb, ccc;              // Több int változó deklarálása egy sorban
int x = 2, y = 3, z = 91;       // Több int v. deklarálása és definílása egy sorban
Debug.Log(myFirstVariable);     // Kiíratása a konzolra ⚠️ Unity-n belül ⚠️
Console.WriteLine("Something"); // Kiíratása a konzolra ⚠️ Unity-n kívül ⚠️

// Az értékadás (definiálás) kötelező a használat előtt!
        
// var kulcszó: Implicit típusadás (Az érték alapján választja a típust)
var i_i = 1;                    // int típus
var i_f = 1.23f;                // float típus
var i_s = "string";             // string típus
var i_b = true;                 // bool típus

// C#-ben a változók neve mindig kezdődjön kisbetűvel!

int a = 5, b = 3;
	
int c = a + b;			// Összeadás:		c = 8
int d = a - b;			// Kivonás:			d = 2
int e = a * b;			// Szorzás:			e = 15
int f = a / b;			// Osztás:			f = 1     // ⚠️ NEM PEDIG 1.6666... ⚠️
f = b / a;					// 							f = 0     // ⚠️ NEM PEDIG 0.6 ⚠️
// ⚠️ Intek osztásánál elveszítjük a tizedes tört részt ⚠️

int g = a % b;			// Maradék:			g = 2      
int h = -a;					// Negálás:			j = -5

int i = 5;
float j = 3f;

// Rövidítések:
d += 6;             // d = d + 6
e -= a;             // e = e - a
f *= 2;             // f = f * 2
g /= a;             // g = g / a
h++;                // j = j + 1
++h;                // j = j + 1
h--;                // j = j - 1
--h;                // j = j - 1
int k = a++;        // k = a; a = a + 1;
int l = ++a;        // a = a + 1; l = a;

// C# tiszteli a matematikai műveleti sorrendet de használható a zárójel:

int m = a + b * c;      // int x = b * c; 
												// int m = a + x;

int n = (a + b) * c;    // int x = a + b;
												// int n = x * c;

string s = "aa" + "bb";	// String összefűzés: s = "aabb"
    
// Az összefűzés és az összeadás (mindakettőt a + operátorral tesszük)

s = "s";
int i = 5;
float f = 3f;
string result;

result = s + i;					// string + number = string
												// Eredmény : "s5" 

result = s + i + f;			// 1. lépés: string + int = string 
                        // 2. lépés: string + float = string
                        // Eredmény : "s53"
        
result = s + (i + f);		// Ha zárójelet haználunk:
												// 1. lépés: int + float = float
                        // 2. lépés: string + float = string
                        // Eredmény : "s8"

result = $"Values: {i}, {f}";		// Ha a $ szimbólumot a string elé tesszük,
 																// akkor változók értékeit beilleszthetjük
 																// a stringbe kapcsos zárójelek közt.

// A logikai típus: Egy eldöntendő kérdésre ad választ.
// Két értéket vehet fel:
bool a = true;					// Igaz
bool b = false;					// Hamis

int i1 = 2, i2 = 3;

bool equalityCheck = i1 == i2;		// Megegyezik-e i1 és i2 értéke?
bool relationCheck1 = i1 > 5;			// i1 értéke nagyobb, mint 5?
bool relationCheck2 = -2 < i2;		// -2 kisebb, mint i2 értéke?
bool relationCheck3 = i1 >= i2;		// i1 értéke nagyobb vagy egyenlő, mint i2 értéke?
bool relationCheck4 = i1 <= 8;		// i1 értéke kisebb vagy egyenlő, mint 8?
bool stringEqualityCheck = "someString" == "otherString";
																	// Megegyezik-e ez a két szöveg?

// Boole algebra:  A logikai típus matematikája

// A bool típus műveletei:
bool a_negated = !a;              // NO : Logikai negálás
bool a_or_b = a || b;             // OR : Logikai vagy
bool a_and_b = a && b;            // AND : Logikai és
bool a_xor_b = a ^ b;             // XOR : Logikai kizáró vagy

// Összetett logikai kifejezés:
bool is_i_EvenOrNegative = (i1 > 0 && i1 % 2 == 0) || i1<=0;

int i = 4;
float f = 5.3f;

// Casting = Egy típus átalakítása aegy másikba 

// Implicit cast-olás:
// int-ből floal-ba castolás implicit: Automatikus
float f1 = i;		  	// Implicit cast-olás int-ből float-ba
float f2 = i / 3;   // ⚠️ 1. lépés: osztás (int / int = int) ⚠️
										// ⚠️ 2. lépés: cast-olás ⚠️
										// ⚠️ Eredmény: (4/3) => 1 (levágtuk a törtrészt) => 1f ⚠️

// Explicit cast-olás
// float-ból int-be castolás csak explicit lehetséges:  ki kell írni, hogy (int)
int i2 = (int) f;
   
// Amikor a cast-olás nem elég:

string s1 = f1.ToString();	// Bármit string-gé lehet alakítani a ToString()-gel
string s2 = i1.ToString();	// Nem csak számokat

float s3 = float.Parse(s1);	// Szövegből szám: Parse-olás
int s4 = int.Parse(s2 );		// Számokra működik
														// ⚠️ Nem biztos, hogy helyes:⚠️
														// ⚠️ Ha a bemeneti string nem számot ír le, hibát dob! ⚠️