03. TANANYAG · FORRÁSKÓD
Adattípusok
03_Adattipusok_kommentelt.csAnimáció megnyitása →
namespace Adattipusok // A namespace (névtér) összefogja és elkülöníti az ide tartozó kódelemeket; ennek a névtérnek a neve Adattipusok.
{ // A nyitó kapcsos zárójel jelzi, hogy itt kezdődik az Adattipusok névtérhez tartozó kódblokk.
internal class Program // Az internal azt jelenti, hogy ez az osztály ezen az assemblyn belül érhető el; a class egy Program nevű osztályt definiál.
{ // Itt kezdődik a Program osztály törzse.
static void Main(string[] args) // A Main a program belépési pontja; static: példány nélkül futtatható, void: nem ad vissza értéket, string[] args: parancssori argumentumok tömbje.
{ // Itt kezdődik a Main metódus törzse.
// EGÉSZ TÍPUSOK – egész számok tárolására használható adattípusok.
int szám; // Egy int típusú, szám nevű változó deklarációja. Az int előjeles, 32 bites egész számot tárol.
uint aOldal; // Egy uint típusú változó deklarációja. A uint előjel nélküli (unsigned), 32 bites egész; az aOldal név camelCase elnevezési módot követ.
// aOldal = -1; // Ez fordítási hibát okozna, mert a uint nem tud negatív értéket tárolni.
byte életkor; // Egy byte típusú változó deklarációja. A byte előjel nélküli, 8 bites egész, értéktartománya 0–255.
ulong vagyon = 123345645675678; // Deklaráció és inicializálás egy lépésben: létrejön a vagyon nevű ulong változó, és rögtön kezdőértéket kap.
char c = 'a'; // Egy char típusú, c nevű változó létrehozása és inicializálása. A char egyetlen UTF-16 kódegységet tárol; a karakterliterált egyszeres idézőjelek közé írjuk.
// cw – Visual Studio-kódrészlet (snippet): bizonyos környezetekben gyorsan létrehozható vele egy Console.WriteLine() hívás.
Console.WriteLine(c); // Kiírja a c változó aktuális értékét, vagyis az 'a' karaktert, majd új sort kezd.
Console.WriteLine(c + 1); // A char aritmetikai műveletben számmá alakul; az 'a' kódértékéhez 1 adódik, ezért itt egy egész szám íródik ki, nem a 'b' karakter.
c = '\''; // A c új értéke az aposztróf karakter. A \' úgynevezett escape szekvencia, amellyel az egyszeres idézőjel karaktert tudjuk leírni.
c = '\n'; // A c új értéke az újsor karakter. A \n escape szekvencia sortörést jelent.
c = '\t'; // A c új értéke a tabulátor karakter. A \t escape szekvencia vízszintes tabulátort jelent.
// ASCII – egy régebbi karakterkódolási szabvány, amely számértékeket rendel karakterekhez.
// UTF-8 – változó hosszúságú Unicode-kódolás; egy karakter kódolásához 1–4 bájtot használhat.
// C#-ban a char típust nem az UTF-8, hanem a .NET UTF-16 alapú karaktermodelljéhez kell kapcsolni.
// VALÓS TÍPUSOK – törtrészt is tartalmazó számok tárolására használható típusok.
float távolság = 123.123456789F; // float típusú változó. Az F utótag jelzi, hogy a literál float legyen; a float kb. 6–9 számjegynyi pontosságot ad.
Console.WriteLine(távolság); // Kiírja a távolság változó ténylegesen eltárolt float értékét.
double testtömeg = 72.12345678923; // double típusú változó. A double nagyobb pontosságú lebegőpontos típus, mint a float.
Console.WriteLine(testtömeg); // Kiírja a testtömeg változó értékét.
decimal nagyonPontosSzám = 1.12234534565356342344M; // decimal típusú változó. Az M utótag decimal literált jelöl; különösen pénzügyi, nagy tizedes pontosságot igénylő számításoknál hasznos.
// LOGIKAI – két lehetséges igazságértéket tároló típus.
bool logikai = true; // Egy bool típusú változó létrehozása true (igaz) kezdőértékkel.
logikai = false; // Értékadás: a már létező logikai változó értékét false-ra (hamisra) módosítjuk.
// STRING – szövegek tárolására használt típus.
string szöveg = "Lorem ipsum"; // Egy string típusú változó létrehozása és inicializálása. A string szöveget tárol; a szövegliterált dupla idézőjelek közé írjuk.
szöveg = ""; // A szöveg változó új értéke az üres string: létező szövegérték, amelynek a hossza 0.
} // Ez a záró kapcsos zárójel lezárja a Main metódus törzsét.
void MásikFüggvény() // Egy MásikFüggvény nevű metódus deklarációja. A void azt jelenti, hogy a metódus nem ad vissza értéket.
{ // Itt kezdődik a MásikFüggvény metódus törzse.
/* Több soros komment:
A Main() metódusban
deklarált helyi változók itt
már nem érhetők el, mert a hatókörük
a Main metódus kódblokkjára korlátozódik.
*/
} // Ez a záró kapcsos zárójel lezárja a MásikFüggvény metódust.
} // Ez a záró kapcsos zárójel lezárja a Program osztályt.
} // Ez az utolsó záró kapcsos zárójel lezárja az Adattipusok névteret.
/*
* VÁLTOZÓ DEKLARÁCIÓJA, INICIALIZÁLÁSA ÉS ÉRTÉKADÁS
* -------------------------------------------------
*
* Egy változó létrehozásának általános formája:
*
* [típus] [változónév];
*
* Például:
*
* int szám;
*
* A felépítése:
*
* int szám
* ↓ ↓
* típus változónév
*
* Ezt deklarációnak nevezzük: megmondjuk a fordítónak, hogy legyen egy
* "szám" nevű változó, amely int típusú értéket képes tárolni.
*
* Ha már a létrehozás pillanatában kezdőértéket is adunk neki:
*
* int szám = 10;
*
* akkor deklaráció és inicializálás történik egyszerre.
*
* int szám = 10;
* ↓ ↓ ↓ ↓
* típus név értékadó kezdőérték
* operátor
*
* Ha a változó már korábban létrejött:
*
* int szám;
* szám = 10;
*
* akkor a második sor egyszerű értékadás.
*
* Fontos tehát:
*
* int szám; -> deklaráció
* int szám = 10; -> deklaráció + inicializálás
* szám = 20; -> értékadás
*/
/*
* EGÉSZ SZÁMTÍPUSOK: int, uint, byte, ulong
* -----------------------------------------
*
* A C# több különböző egész számtípust biztosít. Ezek többek között
* abban különböznek, hogy hány biten tárolják az értéket, illetve
* engednek-e negatív számokat.
*
* int szám;
*
* Az int 32 bites, előjeles egész szám.
* Vagyis negatív, nulla és pozitív értékeket is tárolhat.
*
* uint aOldal;
*
* A uint szintén 32 bites, de unsigned, azaz előjel nélküli.
* Ezért csak 0 vagy pozitív egész értéket tárolhat.
*
* aOldal = -1;
*
* nem megengedett, mert -1 kívül esik a uint értéktartományán.
*
* byte életkor;
*
* A byte 8 bites, előjel nélküli egész. Értéktartománya:
*
* 0 ... 255
*
* Kis, biztosan nem negatív értékekhez használható.
*
* ulong vagyon = 123345645675678;
*
* A ulong 64 bites, előjel nélküli egész típus, ezért nagyon nagy
* pozitív egész számokat is képes tárolni.
*
* Általánosan:
*
* signed -> előjeles, lehet negatív is
* unsigned -> előjel nélküli, nem lehet negatív
*/
/*
* char – EGY KARAKTER ÉS AZ ESCAPE SZEKVENCIÁK
* ---------------------------------------------
*
* A char egy karakterjellegű érték tárolására szolgáló értéktípus.
* Egy char literált egyszeres idézőjelek közé írunk:
*
* char c = 'a';
*
* Nem ugyanaz, mint a string:
*
* char betű = 'a';
* string szöveg = "a";
*
* Az első egy char, a második egy string.
*
* A C# char 16 bites és egy UTF-16 kódegységet tárol.
* Emiatt a "char = egy teljes Unicode-karakter" megfogalmazás bizonyos
* ritkább karaktereknél nem mindig pontos: vannak Unicode-jelek, amelyek
* két char értékből álló úgynevezett surrogate pairt igényelnek.
*
* Az escape szekvenciák speciális karakterek leírására szolgálnak:
*
* '\n' -> újsor
* '\t' -> tabulátor
* '\'' -> egyszeres idézőjel
* '\\' -> backslash
*
* A következő kifejezésnél:
*
* c + 1
*
* a char numerikus műveletben egész számmá alakul.
* Ha c értéke 'a', akkor Console.WriteLine(c + 1) nem "b"-t ír ki,
* hanem az eredményként kapott egész számot.
*
* Ha karakterként szeretnénk az eredményt:
*
* Console.WriteLine((char)(c + 1));
*/
/*
* ASCII, UNICODE, UTF-8 ÉS UTF-16
* ------------------------------
*
* Fontos különbséget tenni a karakter és annak kódolása között.
*
* Az ASCII egy régebbi karakterkészlet/kódolási szabvány, amely
* alapvetően 128 karaktert definiál.
*
* A Unicode egy sokkal nagyobb karakterkészlet, amely a világ
* írásrendszereinek karaktereihez kódpontokat rendel.
*
* Az UTF-8 és az UTF-16 a Unicode karakterek kódolásának két különböző módja.
*
* UTF-8 -> változó hosszúságú, 1–4 bájt
* UTF-16 -> jellemzően 1 vagy 2 darab 16 bites kódegység
*
* A C#/.NET char típusa egy 16 bites UTF-16 kódegységet tárol.
*/
/*
* VALÓS SZÁMTÍPUSOK: float, double, decimal
* -----------------------------------------
*
* Törtrészt tartalmazó számokhoz több típust is használhatunk.
*
* float távolság = 123.123F;
* double testtömeg = 72.123456789;
* decimal ár = 19.99M;
*
* A float és a double lebegőpontos típus.
* A double nagyobb pontosságot biztosít, ezért általános számításokhoz
* rendszerint ezt használjuk gyakrabban.
*
* A literál végén található F azt mondja meg a fordítónak, hogy az
* adott szám float típusú:
*
* 12.5F
*
* Tizedespontos szám literálja alapértelmezés szerint double.
*
* A decimal más reprezentációt használ, és különösen olyan esetekben
* hasznos, ahol fontos a tízes számrendszer szerinti nagy pontosság,
* például pénzügyi számításoknál.
*
* A decimal literál M utótagot kap:
*
* 19.99M
*
* Röviden:
*
* float -> kisebb pontosság, kisebb tárhely
* double -> általános célú, nagyobb pontosságú lebegőpontos típus
* decimal -> nagy tizedes pontosság, gyakori pénzügyi használat
*/
/*
* bool – LOGIKAI TÍPUS
* --------------------
*
* A bool logikai értéket tárol. Két lehetséges értéke van:
*
* true -> igaz
* false -> hamis
*
* Például:
*
* bool bejelentkezett = true;
*
* Később az értéke módosítható:
*
* bejelentkezett = false;
*
* A bool típus különösen feltételeknél fontos:
*
* if (bejelentkezett)
* {
* Console.WriteLine("Sikeres bejelentkezés.");
* }
*/
/*
* string – SZÖVEG
* ---------------
*
* A string szöveget tárol:
*
* string név = "Anna";
*
* A string literált dupla idézőjelek közé írjuk.
*
* Az üres string:
*
* ""
*
* nem azt jelenti, hogy nincs változó, hanem azt, hogy a string
* létezik, csak nulla karakter hosszúságú:
*
* string szöveg = "";
*
* Ez különbözik a null értéktől, amely azt jelzi, hogy nincs
* hivatkozott string objektum.
*/
/*
* HATÓKÖR (SCOPE) – HOL ÉRHETŐ EL EGY VÁLTOZÓ?
* ---------------------------------------------
*
* A Main metóduson belül deklarált változók helyi változók:
*
* static void Main(string[] args)
* {
* int szám = 10;
* }
*
* A "szám" változó csak abban a kódblokkban érhető el, amelyben
* létrehoztuk.
*
* Egy másik metódus:
*
* void MásikFüggvény()
* {
* // A "szám" itt már nem érhető el.
* }
*
* A { } kapcsos zárójelek ezért nemcsak a kód szerkezetét mutatják:
* sok esetben a változók hatókörének határát is kijelölik.
*/
/*
* void MásikFüggvény()
* --------------------
*
* Ez egy metódus deklarációja:
*
* void MásikFüggvény ()
* ↓ ↓ ↓
* visszatérési metódus paraméterlista
* típus neve
*
* A void azt jelenti, hogy a metódus nem ad vissza értéket.
*
* A () azt jelzi, hogy ennek a metódusnak jelenleg nincs paramétere.
*
* Általánosított forma:
*
* [visszatérési típus] [metódusnév]([paraméterek])
*
* Például:
*
* int Dupla(int szám)
* {
* return szám * 2;
* }
*
* Fontos: a példában szereplő MásikFüggvény nem static.
* Emiatt közvetlenül a static Main metódusból csak egy Program
* objektumon keresztül lehetne meghívni.
*/
namespace Adattipusok
{
internal class Program
{
static void Main(string[] args)
{
int szám;
uint aOldal;
byte életkor;
ulong vagyon = 123345645675678;
char c = 'a';
Console.WriteLine(c);
Console.WriteLine(c + 1);
c = '\'';
c = '\n';
c = '\t';
float távolság = 123.123456789F;
Console.WriteLine(távolság);
double testtömeg = 72.12345678923;
Console.WriteLine(testtömeg);
decimal nagyonPontosSzám = 1.12234534565356342344M;
bool logikai = true;
logikai = false;
string szöveg = "Lorem ipsum";
szöveg = "";
}
void MásikFüggvény()
{
}
}
}