Készítette: Nagy Tibor Istvánusers.nik.uni-obuda.hu/nagyt/OOP/Valtozok_tipusok.pdf · A változó Egy memóriában elhelyezkedő „rekesz” Egy értéket tárol Van azonosítója

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


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


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


tevékenységek C#-ban

(melyik kód helyes?) int i;

Console.WriteLine(i);

i = 8;

int i;


i = 8;

int i;

int i;

i = 8;


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");


(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í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


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}

};


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]);




Console.WriteLine(

tomb[tomb.Length]);


tomb[3] = 22;





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);

}

}



{

for(int i=0;i<2;++i)

{

int j = 20;

}

Console.Write(i+j);

}

void Met()

{

int j;


{

Console.Write(i);

}

Console.Write(j);

}



{

int i = 9;

if(i > 0)

{

int i = 12;

}

}

void Met()

{


{

Console.Write(i);

}

int i = 6;

Console.Write(i);

}



{

for(int i=0; i<2;++i)

{


{

}

}

}

void Met()

{

for(int i=0;i<2;++i) {

Console.Write(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;



25 a

cím1 int a;

a = 25;



25 a

cím1 int a;

a = 25;

Console.Write( a );



25 a

cím1

b

cím2

int a;

a = 25;

Console.Write( a );

int b;



25 a

cím1

25 b

cím2

int a;

a = 25;

Console.Write( a );

int b;

b = a;



10 a

cím1

25 b

cím2

int a;

a = 25;

Console.Write( a );

int b;

b = a;

a = 10;



10 a

cím1

25 b

cím2

int a;

a = 25;

Console.Write( a );

int b;

b = a;

a = 10;

Console.Write( a );



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


null a

cím1 int[] a;



null a

cím1 int[] a;

a = new int[1];

0

cím2



cím2 a

cím1 int[] a;

a = new int[1];

0

cím2



cím2 a

cím1 int[] a;

a = new int[1];

a[0] = 25;

25

cím2



cím2 a

cím1

25

cím2

int[] a;

a = new int[1];

a[0] = 25;

Console.Write( a[0] );



cím2 a

cím1

null b

cím3

25

cím2

int[] a;

a = new int[1];

a[0] = 25;


int[] b;



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;


int[] b;

b = new int[1];



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;


int[] b;

b = new int[1];

b[0] = a[0];

Ez még érték

típusú változók

értékadása!



cím2 a

cím1 a[0] = 10;

cím4 b

cím3

10

cím2

25

cím4



cím2 a

cím1 a[0] = 10;


cím4 b

cím3

10

cím2

25

cím4



cím2 a

cím1 a[0] = 10;


Console.Write( b[0] );

cím4 b

cím3

10

cím2

25

cím4



cím2 a

cím1 a[0] = 10;



b = a;

cím2 b

cím3

10

cím2

25

cím4 Referencia

típusú változók

értékadása!



cím2 a

cím1 a[0] = 10;



b = a;


cím2 b

cím3

10

cím2

25

cím4



cím2 a

cím1 a[0] = 10;



b = a;


Console.Write( b[0] ); cím2 b

cím3

10

cím2

25

cím4



cím2 a

cím1 a[0] = 10;



b = a;



a[0] = 20; cím2 b

cím3

20

cím2

25

cím4



cím2 a

cím1 a[0] = 10;



b = a;



a[0] = 20;

b[0] = 30;

cím2 b

cím3

30

cím2

25

cím4



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


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]);


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]);

Documents

Készítette: Nagy Tibor Istvánusers.nik.uni-obuda.hu/nagyt/OOP/Valtozok_tipusok.pdf · A változó Egy memóriában elhelyezkedő „rekesz” Egy értéket tárol Van azonosítója