készítette: nagy tibor istvánusers.nik.uni-obuda.hu/nagyt/oop/valtozok_tipusok.pdf · a...
TRANSCRIPT
Készítette: Nagy Tibor István
A változó Egy memóriában elhelyezkedő „rekesz”
Egy értéket tárol
Van azonosítója (vagyis neve)
Van típusa (milyen értéket tárolhat)
Az értéke értékadással módosítható
Az értéke egy kifejezésben lekérdezhető
Típus A változó típusa meghatározza:
A változóban elhelyezhető érték „jellegét” (logikai, egész szám, valós szám, …)
Az értékhalmazt, melyből a változó felveheti értékét (pl.: [0; 255], [igaz; hamis], [A; Z])
Az ábrázolás módját:
mekkora helyet foglal a változó a memóriában (8, 16, 32, 64, 128 bit)
hogyan tárolódnak benne az értékek (pl.: egy valós számnál a mantissza kettes komplemens kódban, rejtett bit használatával, a karakterisztika pedig többletes formában tárolódhat)
Változókkal végezhető
tevékenységek C#-ban Deklaráció
A változó nevének és
típusának megadása
Értékadás
Érték elhelyezése a
változóban
Érték lekérdezése
A változó tartalmának kiolvasása.
Az érték a kiolvasás után is
megmarad a változóban
Változókkal végezhető
tevékenységek C#-ban Deklaráció
int szam; azonos típusú változók nevei vesszőkkel elválasztva
típus változónév
Értékadás
szam = 25; vagy szam = 6 * 2 – 29;
érték kifejezés
Érték lekérdezése
5 * 10 – szam + 2
a név helyettesítődik a változó értékével
Változókkal végezhető
tevékenységek C#-ban A tevékenységek sorrendje:
1. Deklaráció
2. Értékadás
3. Érték lekérdezése
A fentiek közül akármelyik tevékenységet
szeretnénk is végrehajtani, előbb a sorrendben őt
megelőző tevékenységet kell elvégezni!
A deklaráció és a kezdeti értékadás összevonható
egy utasításba
Változókkal végezhető
tevékenységek C#-ban
(melyik kód helyes?) int i;
Console.WriteLine(i);
i = 8;
int i;
Console.WriteLine(i);
i = 8;
int i;
int i;
i = 8;
Console.WriteLine(i);
int i;
int j = i * 2 – 8;
int j = i * 5 – 2;
int i;
Típusok C#-ban
Logikai
Egész szám
Valós szám
Karakter Sztring
Alaptípusok bool
byte, short, int, long,
sbyte, ushort, uint, ulong
float, double, decimal
string char
Típusok a C#-ban Név Értékhalmaz Helyfoglalás (bit)
bool [true; false]
char U 16
string U* 0 - 232 db karakter
byte, sbyte [0; 255], [-128; 127] 8
short, ushort [-32708; 32767], [0; 65535] 16
int, uint [-2,1*109; 2,1*109], [0; 4,2*109] 32
long, ulong [-9*1018; 9*1018], [0; 18*1018] 64
float [-3,4*1038; 3,4*1038] (7 tizedes) 32
double [±5*10-324; ±1,7*10308] (15-16 tizedes) 64
decimal [-7,9*1028; 7,9*1028] (28-29 tizedes) 128
U = a Unicode karakterek halmaza
Értékadás Baloldalon csak változó (vagy tulajdonság, vagy
indexelő) szerepelhet
A baloldal és jobboldal típusa meg kell, hogy
egyezzen (vagy léteznie kell a jobboldalt baloldali
típusúvá alakító implicit konverziónak)
Ha a két oldal típusa nem egyezik, akkor
konverzióval a jobb oldalt át kell alakítani a baloldal
típusára
Típuskonverzió (beépített típus)
(Sztring Adott típus) Általános formátum:
celtipus.Parse(sztring_kifejezes);
Példa:
string s = "986";
int i = int.Parse(s);
float f = float.Parse("986");
bool b = bool.Parse("false");
Típuskonverzió (beépített típus)
(Adott típus Sztring) Általános formátum:
adott_tipusu_kifejezes.ToString()
Példa:
int i = 986;
string s = i.ToString();
string s2 = 986.ToString();
string s3 = (986 * 2 / 124).ToString();
string s4 = i.ToString();
string s5 = i.ToString();
Típuskonverzió (beépített típus)
(Típus1 Típus2) Sem az átalakítandó kifejezés, sem a céltípus nem
sztring
Általános formátum:
(tipus2)tipus1_tipusu_kifejezes
Példa:
double d = 456.78;
int i = (int)d;
int j = (int)456.78;
int k = (int)(34,56 + 78 * 2);
Literálok A programkódba közvetlenül beírt értékek
A literáloknak is van típusuk
A literálokkal műveletek végezhetők
Példa:
int k = 28; egész literál
double d = 5.67; valós literál
string s = "Hello!"; sztring literál
char c = 'L'; karakter literál
bool b = true; logikai literál
Egész literálok Formátumuk:
decimális: 255;
hexadecimális: 0xFF;
Típusuk:
int, uint, long, vagy ulong (ebben a sorrendben) attól
függően, hogy melyik típusban fér el a megadott érték
A literál típusa módosítható a literál mögé írt betűkkel
U : uint, vagy ulong (pl.: 255U)
L : long vagy ulong (pl.: -356L)
UL : ulong (pl.: 222UL)
Egész literálok (milyen típusúak
a következő literálok?) 345
-2 000
2 300 000 000
-2 300 000 000
-2 000L
2 000L
2 000U
2 000UL
2 300 000 000L
2 300 000 000U
2 300 000 000UL
Valós literálok Formátumuk:
hagyományos: 0.0123456
tudományos: 1.23456E-2
Típusuk:
alapértelmezésben double
A típusuk módosítható a literál mögé írt betűkkel:
F : float (pl.: 3.45F)
D : double (pl.: 3.45D)
M : decimal (pl.: 3.45M)
Karakterliterálok Típusuk char
Formátumuk:
Karakter konkrét megadása: 'A'
Megadás hexa unicode-dal: ' \x1234 ' vagy ' \u1234 '
Speciális karakter megadása:
Karakter Megadása Karakter Megadása
' \' form feed \f
" \" új sor \n
\ \\ kocsi vissza \r
null \0 horiz. tabulátor \t
alert \a vertik. tabulátor \v
backspace \b
Sztringliterálok Formátumuk:
Normál megadás: "karakterek sorozata"
"Szó szerinti" megadás: @"karakterek sorozata"
Típusuk string
Sztringliterálok
(mi jelenik meg a képernyőn?) Console.Write("Szia\nHello\nViszlát");
Console.Write(@"Szia\nHello\nViszlát");
Console.Write("Szia, \"Jenő\"!");
Console.Write("\\\\server\\share\\file.txt");
Console.Write(@"\\\\server\\share\\file.txt");
A tömb Több, memóriában
elhelyezkedő „rekesz”
együttese
Több, azonos típusú értéket tárol
Van azonosítója (vagyis neve)
Van típusa (az elemek típusa)
Elemei a tömbön belüli sorszámukkal (index) érhetők
el
Egy elem értéke értékadással módosítható
Egy elem értéke egy kifejezésben lekérdezhető
Tömbbel végezhető
tevékenységek Deklaráció
A tömb nevének és elemei típusának megadása
Tömblétrehozás A tömb méretének meghatározása
Értékadás Érték elhelyezése egy tömbelemben
Érték lekérdezése Egy tömbelem tartalmának kiolvasása. Az érték a kiolvasás után is megmarad a tömbelemben
Tömbbel végezhető
tevékenységek C#-ban 1. Deklaráció
int[] tomb;
3. Értékadás
tomb[5] = 25; vagy tomb[5] = 6 * 2 – 29;
4. Érték lekérdezése
5 * 10 – tomb[5] + 2
2. Tömblétrehozás
tomb = new int[10];
A deklaráció és a tömblétrehozás összevonható:
int[] tomb = new int[10];
Tömbelem elérése
(indexelés) A tömb egy adott eleméhez a tömb neve után szögletes
zárójelek között megadott sorszámmal (index) férhetünk
hozzá:
tömbnév[index]
Az index csak egész szám lehet
A tömb első elemének indexe: 0
A tömb utolsó elemének indexe: elemszám – 1
Kisebb, vagy nagyobb index megadása futási hibát okoz.
28 3 17 11 50
0. 1. 2. 3. 4.
tomb tomb = new int[5];
tomb[3]
Tömb hosszának (elemei
számának) lekérdezése Általános formátum:
tömbnév.Length
A tömbben lévő elemek számát adja meg
28 3 17 11 50
0. 1. 2. 3. 4.
tomb tomb = new int[5];
tomb.Length
Tömb inicializálása A tömb deklarációja, létrehozása és elemeinek
megadása egy utasításban is elvégezhető
Formátuma:
típus tömbnév = {elem1, elem2, …, elemN};
Példa:
double[] valosak = {2.0, -3, 5, 8.2, -1234.56};
bool[] logikai = {true, false, false, false, true, true};
int[,] egeszmatrix = {{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 0, 1, 2}
};
Tömbbel végezhető
tevékenységek C#-ban A tevékenységek sorrendje:
1. Deklaráció
2. Tömblétrehozás
3. Értékadás egy tömbelemnek, vagy egy tömbelem értékének lekérdezése
A fentiek közül akármelyik tevékenységet szeretnénk is végrehajtani, előbb a sorrendben őt megelőző tevékenységet kell elvégezni!
A tömbelemeknek nem kötelező értéket adni az érték lekérdezése előtt
Értékadás hiányában a tömbelem a típus alapértékét veszi fel
Tömbbel végezhető tevékenységek
C#-ban
(melyik kód helyes?) int[] tomb;
Console.WriteLine(tomb[2]);
int[] tomb = new int[4];
Console.WriteLine(tomb[4]);
int[] tomb = new int[4];
Console.WriteLine(
tomb[tomb.Length]);
int[] tomb = new int[4];
tomb[3] = 22;
Console.WriteLine(tomb[3]);
int[] tomb = new int[4];
Console.WriteLine(tomb[0]);
int[] tomb = new int[4];
Console.WriteLine(tomb[-1]);
Többdimenziós tömbök 2 dimenziós tömb
sorok és oszlopok
elem elérése 2 indexszel
3 dimenziós tömb
sorok, oszlopok, lapok
elem elérése 3 indexszel
N dimenziós tömb
0., 1., … N. dimenzió
elem elérése N indexszel
Többdimenziós tömbök –
Deklaráció Általános formátum:
típus[ vesszők ] tömbnév;
A szögletes zárójelbe dimenziószám-1 darab
vesszőt kell tenni
Példák:
int[,] matrix;
bool[,,] haromdimenziostomb;
double[,,,,] otdimenziostomb;
Többdimenziós tömbök –
Tömblétrehozás Általános formátum:
tömbnév = new tipus [elemszám1, …, elemszámN]
Az egyes dimenziók elemszámait vesszőkkel
elválasztva kell megadni
A deklaráció és a tömblétrehozás itt is összevonható
Példák
matrix = new int[3, 5];
haromdimenziostomb = new bool [4, 2, 5];
otdimenziostomb = new double[3, 3, 4, 1, 7];
int t[,,] = new int[3, 3, 3];
Tömbelem elérése
(indexelés) A szögletes zárójelek közé a tömbelem minden
egyes dimenzióján belüli sorszámait kell vesszőkkel elválasztva megadni: tömbnév[index1, index2, …, indexN]
Az indexekre vonatkozó szabályok u.a., mint az egydimenziós tömbnél
pontosan annyi indexet kell megadni, ahány dimenziós a tömb
tomb tomb = new int[2, 5];
tomb[1, 3]
28 3 17 11 50
0. 1. 2. 3. 4.
22 14 38 20 1
0.
1.
Tömb hosszának (elemei
számának) lekérdezése Elemek számának lekérdezése:
Összes tömbben lévő elem darabszáma:
tömbnév.Length
Egy adott dimenzió elemszáma (sorok száma,
oszlopok száma, …):
tömbnév.GetLength(dimenziósorszám);
tomb
tomb = new int[ 2, 5 ];
tomb.GetLength(1);
tomb.GetLength(0);
28 3 17 11 50
0. 1. 2. 3. 4.
22 14 38 20 1
0.
1.
Változók hatóköre Hatókör a programkód azon része, melyben a
változóra csupán a nevével (minősítés nélkül)
hivatkozhatunk
Változók fajtái hatókör szerint
(blokkra) lokális változó
tagváltozó
Blokkra lokális változó Az őt deklaráló blokkon belül létezik
A deklaráció helyétől a blokkot záró kapcsos
zárójelig használható
A metódus-paraméterek is ide tartoznak
A metódus-paraméterek a metódus törzsén belül
használhatóak
Két lokális változó csak egymástól elkülönülő
blokkokban deklarálható azonos néven, egymásba
ágyazott blokkokban ez nem lehetséges!
Blokkra lokális változó
(melyik kód helyes?) void Met()
{
Console.Write(i);
int i = 6;
}
void Met()
{
int i = 6;
if(i % 6 == 0)
{
Console.Write(i);
}
}
Blokkra lokális változó
(melyik kód helyes?) void Met()
{
for(int i=0;i<2;++i)
{
int j = 20;
}
Console.Write(i+j);
}
void Met()
{
int j;
for(int i=0;i<2;++i)
{
Console.Write(i);
}
Console.Write(j);
}
Blokkra lokális változó
(melyik kód helyes?) void Met()
{
int i = 9;
if(i > 0)
{
int i = 12;
}
}
void Met()
{
for(int i=0;i<2;++i)
{
Console.Write(i);
}
int i = 6;
Console.Write(i);
}
Blokkra lokális változó
(melyik kód helyes?) void Met()
{
for(int i=0; i<2;++i)
{
for(int i=0;i<4;++i)
{
}
}
}
void Met()
{
for(int i=0;i<2;++i) {
Console.Write(i);
}
for(int i=0;i<8;++i)
{
Console.Write(i);
}
}
Érték- és referenciatípusú
változók Értéktípusú változók
Konkrét értéket tárolnak
Az "a = b" értékadáskor a b értéke átmásolódik a-ba
egész, valós, logikai, karakter, felsorolás típusok
Referenciatípusú változók
Csak egy hivatkozást tárolnak a konkrét értékre
Az "a = b" értékadáskor a b ugyanazon memóriacímen
lévő értékre fog hivatkozni, mint a.
tömb, osztály, interfész, delegált, esemény típusok
Változók a memóriában
(sematikus ábra) Memória
345 a
cím1
true b
cím2
34.45 d
cím3
Érték típusú változók a
memóriában 1. (sematikus ábra) Memória
a
cím1 int a;
Érték típusú változók a
memóriában 2. (sematikus ábra) Memória
25 a
cím1 int a;
a = 25;
Érték típusú változók a
memóriában 3. (sematikus ábra) Memória
25 a
cím1 int a;
a = 25;
Console.Write( a );
Érték típusú változók a
memóriában 4. (sematikus ábra) Memória
25 a
cím1
b
cím2
int a;
a = 25;
Console.Write( a );
int b;
Érték típusú változók a
memóriában 5. (sematikus ábra) Memória
25 a
cím1
25 b
cím2
int a;
a = 25;
Console.Write( a );
int b;
b = a;
Érték típusú változók a
memóriában 6. (sematikus ábra) Memória
10 a
cím1
25 b
cím2
int a;
a = 25;
Console.Write( a );
int b;
b = a;
a = 10;
Érték típusú változók a
memóriában 7. (sematikus ábra) Memória
10 a
cím1
25 b
cím2
int a;
a = 25;
Console.Write( a );
int b;
b = a;
a = 10;
Console.Write( a );
Érték típusú változók a
memóriában 8. (sematikus ábra) Memória
10 a
cím1
25 b
cím2
int a;
a = 25;
Console.Write( a );
int b;
b = a;
a = 10;
Console.Write( a );
Console.Write( b );
Referencia típusú változók a
memóriában 1. (sematikus ábra) Memória
null a
cím1 int[] a;
Referencia típusú változók a
memóriában 2. (sematikus ábra) Memória
null a
cím1 int[] a;
a = new int[1];
0
cím2
Referencia típusú változók a
memóriában 3. (sematikus ábra) Memória
cím2 a
cím1 int[] a;
a = new int[1];
0
cím2
Referencia típusú változók a
memóriában 4. (sematikus ábra) Memória
cím2 a
cím1 int[] a;
a = new int[1];
a[0] = 25;
25
cím2
Referencia típusú változók a
memóriában 5. (sematikus ábra) Memória
cím2 a
cím1
25
cím2
int[] a;
a = new int[1];
a[0] = 25;
Console.Write( a[0] );
Referencia típusú változók a
memóriában 6. (sematikus ábra) Memória
cím2 a
cím1
null b
cím3
25
cím2
int[] a;
a = new int[1];
a[0] = 25;
Console.Write( a[0] );
int[] b;
Referencia típusú változók a
memóriában 7. (sematikus ábra) Memória
cím2 a
cím1
cím4 b
cím3
25
cím2
0
cím4
int[] a;
a = new int[1];
a[0] = 25;
Console.Write( a[0] );
int[] b;
b = new int[1];
Referencia típusú változók a
memóriában 8. (sematikus ábra) Memória
cím2 a
cím1
cím4 b
cím3
25
cím2
25
cím4
int[] a;
a = new int[1];
a[0] = 25;
Console.Write( a[0] );
int[] b;
b = new int[1];
b[0] = a[0];
Ez még érték
típusú változók
értékadása!
Referencia típusú változók a
memóriában 9. (sematikus ábra) Memória
cím2 a
cím1 a[0] = 10;
cím4 b
cím3
10
cím2
25
cím4
Referencia típusú változók a
memóriában 10. (sematikus ábra) Memória
cím2 a
cím1 a[0] = 10;
Console.Write( a[0] );
cím4 b
cím3
10
cím2
25
cím4
Referencia típusú változók a
memóriában 11. (sematikus ábra) Memória
cím2 a
cím1 a[0] = 10;
Console.Write( a[0] );
Console.Write( b[0] );
cím4 b
cím3
10
cím2
25
cím4
Referencia típusú változók a
memóriában 12. (sematikus ábra) Memória
cím2 a
cím1 a[0] = 10;
Console.Write( a[0] );
Console.Write( b[0] );
b = a;
cím2 b
cím3
10
cím2
25
cím4 Referencia
típusú változók
értékadása!
Referencia típusú változók a
memóriában 13. (sematikus ábra) Memória
cím2 a
cím1 a[0] = 10;
Console.Write( a[0] );
Console.Write( b[0] );
b = a;
Console.Write( a[0] );
cím2 b
cím3
10
cím2
25
cím4
Referencia típusú változók a
memóriában 14. (sematikus ábra) Memória
cím2 a
cím1 a[0] = 10;
Console.Write( a[0] );
Console.Write( b[0] );
b = a;
Console.Write( a[0] );
Console.Write( b[0] ); cím2 b
cím3
10
cím2
25
cím4
Referencia típusú változók a
memóriában 15. (sematikus ábra) Memória
cím2 a
cím1 a[0] = 10;
Console.Write( a[0] );
Console.Write( b[0] );
b = a;
Console.Write( a[0] );
Console.Write( b[0] );
a[0] = 20; cím2 b
cím3
20
cím2
25
cím4
Referencia típusú változók a
memóriában 16. (sematikus ábra) Memória
cím2 a
cím1 a[0] = 10;
Console.Write( a[0] );
Console.Write( b[0] );
b = a;
Console.Write( a[0] );
Console.Write( b[0] );
a[0] = 20;
b[0] = 30;
cím2 b
cím3
30
cím2
25
cím4
Referencia típusú változók a
memóriában 17. (sematikus ábra) Memória
cím2 a
cím1 Azt a memóriaterületet,
amelyre egyetlen
referenciaváltozó sem
hivatkozik, a GC
automatikusan
felszabadítja cím2 b
cím3
10
cím2
25
cím4
Referencia típusú változók a
memóriában - Feladat Rajzolja le lépésről-lépésre, mi történik a
memóriában a következő kód végrehajtásakor:
int[] t = new int[2];
t[0] = 5; t[1] = 10;
int[] t2 = new int[2];
int i;
for(i = 0; i<2; ++i)
t2[i] = t[i] * t[i];
Console.WriteLine("Számok és négyzeteik");
for(i = 0; i<2; ++i)
Console.WriteLine(t[i] + " négyzete = " + t2[i]);
Referencia típusú változók a
memóriában - Feladat Rajzolja le lépésről-lépésre, mi történik a
memóriában a következő kód végrehajtásakor:
int[] t = new int[2];
t[0] = 5; t[1] = 10;
int[] t2 = new int[2];
int i;
t2 = t;
for(i = 0; i<2; ++i)
t2[i] = t[i] * t[i];
Console.WriteLine("Számok és négyzeteik");
for(i = 0; i<2; ++i)
Console.WriteLine(t[i] + " négyzete = " + t2[i]);