Oszd meg!

Add a Twitter-hez Add a Facebook-hoz Add a Startlaphoz Add az iWiW-hez Add a Google Reader-hez

Közösség

Belépés

E-mail cím:
Jelszó:

Változók használata, integer és string alapismeretei

Változók használata, integer és string alapismeretei

 

A változókat adatok tárolására használjuk. Az adatok különböző típusúak lehetnek. Az adat lehet számolásra alkalmas numerikus típus, szöveges információt hordozó string típus, logikai értéket tároló boolean típus. (A típusok az Excelből ismertek, ott automatikusan alakul ki egy-egy cella típusa a bevitt tartalomtól függően.) Többféle numerikus típusunk van, két nagy csoportja a szám típusoknak az egész és a tizedes tört számok. Az egészek (fixpontosak) és a tizedesek (lebegőpontosak) több altípust tartalmaznak.

     Az integer típusú változókban egész számokat tárolhatunk, tehát az ilyen típusú változóink értéke egész szám lehet. Az ilyen változó –32768-tól  32767-ig vehet fel értékeket. (A jobbaknak, értsd: leendő informatikusok ki kell tudni számolni ezeket az értékeket, érteni kell a miérteket, utána kell járnia a felmerülő kérdéseknek!)

     A string típusú változó szöveg tárolására alkalmas, tehát az ilyen típusú változó értéke bármilyen szöveg lehet, melynek azonban a hossza nem lehet több mint 255 karakter. Ha elég a kisebb hossz, akkor ezt a string mögé beírt számmal jelezzük string[maxhossz] módon. Pl: ha személyek keresztneve nem lehet hosszabb 15 karakternél ekkor a var kernev:string[15]; megoldást alkalmazzuk.

     Amint már említettük, ha változókat akarunk a programunkban használni, azokat a program elején a var kulcsszó után kell felsorolnunk, vagyis deklarálnunk, ahol meg kell adnunk a változóink típusát is. Pl.:

program Pelda04;
var     i:integer;
            s:string;
begin
   i:=-122;
   s:=’Programozó lettem’;
end.

     Ebben a programban két változót deklaráltunk. Az egyik változó neve: i, melynek értéke egész szám lehet, mivel integer típusú. (Az i, j, k, l azonosítókat jellemzően egészek azonosítására használjuk) A másik változó neve: s, amelynek az értéke szöveg lehet (mivel string típusú). A változók neve, ami az esetünkben az i és az s, bármilyen betű vagy szó lehet, de minden változónév csak betűvel kezdődhet és csak az angol ábécé betűit és számokat tartalmazhat. Ha több azonos típusú változót szeretnénk használni, akkor azokat felsorolással, vesszővel elválasztva adhatjuk meg:

program Pelda05a;
      var    a1, a2,a3 :integer;
begin
   a1:=22;
   a2:=12;
   a3:=a1+a2;
end.

     A következő programban 3 változót használunk: a1, a2 és i. Mindhárom változónk integer típusú. Természetesen, ha nekünk úgy jobban tetszik, a változók típusát akár külön-külön is megadhatjuk. Hasonló szerepű változókat csoportosíthatunk a deklarációban, az eredmény ekkor a további használatot és áttekinthetőséget illetően jobb lesz:

program Pelda05b;
var a1,a2,a3 :integer;
    i:integer;
begin

end.

     A fenti programban az a1, a2 és a3 típusát egyszerre, az i változó típusát külön adtuk meg, de ez a programunkon semmit sem változtat. De így jobban áttekinthető a változólista azok szerepe szerint.

     Miután a programunk elején a var szócska után deklaráltuk a változókat, elkezdhetjük ezeket használni a begin kulcsszó utáni végrehajtási részbe írva. A változónak valamilyen értéket a  :=   (olvassuk így: legyen egyenlő) segítségével adhatunk a programban. Például az i változónak így adhatunk értéket (így rakhatjuk bele a 25-ös számot):

i := 25; 

     Szavakkal: i legyen egyenlő 25-tel. Ha szöveges változónak (string) szeretnénk valamilyen értéket adni, akkor hasonlóan mint a Write és WriteLn parancsoknál aposztrófokat kell használnunk:

s:='alma';

     Mivel ez egy értékadó utasítás, amivel a változónak értéket adunk, ezért az értékadás után természetesen pontosvesszőt kell tennünk.

Feladat: Mi a különbség a következő két utasítás között? Milyen esetben szerepelhet a két utasítás egy programban?

a:='z';                  a:=z;

Megoldás: Látjuk, hogy a különbség csak az aposztrófokban van. Mit jelent ez valójában?

·         Az első utasításnál az a változóba beleraktuk a z betűt. Itt csak egy váltózónk van, mégpedig az a, amely egy string típusú változó (mivel egy betűt raktunk bele karakter típus, Char is lehet)

·         A második utasításnál nincs aposztróf. Ez annyit jelent, hogy az a változóba beleraktuk a z változó értékét (tartalmát). Ha például a parancs kiadása előtt z változóban a 25-ös szám volt, akkor a a:=z; paranccsal az a változóba is beleraktunk a 25-ös számot. Ebben az esetben tehát bármi is volt eredetileg az a változóban, a parancs végrehajtása után az a-ban is a 25-ös szám lesz. Amint láthatjuk, itt két ugyanolyan típusú változónk van, mégpedig az a és a z változó. Csak azonos típusú változók között lehet értéket átadni, illetve egy változó érékét a tőle bővebb típusú veheti át.(vagyis itt a real is lehetne ha z-ben egy szám volna)

·         Tehát egy programban akkor szerepelhet a két utasítás, ha a és z változó egyaránt string típusú. (De még így is van egy kis gond.)

  Lássunk most egy kis rövid programot, melyben két változót fogunk használni: a és b. Mindkét változónk integer típusú lesz. A programban az a változóba berakjuk a 8-as számot, a b változóba pedig a 6-ost. Végül kiíratjuk a képernyőre a két változó összegét:

program Pelda06;
var a,b:integer;
begin
 a:=8;
 b:=6;
 WriteLn('A két változó összege: ',a+b);
end.

     Programunk a következőt fogja kiírni a képernyőre:

A ket valtozo osszege: 14
_

     Láthattuk, hogy a kiíratásnál az a+b nincs aposztrófok között. Ez így helyes, hiszen nem azt a három karaktert akartuk kiíratni a képernyőre, hogy: a+b, hanem a két változó értékének az összegét. Jegyezzük meg, hogy a változók értékeinek kiíratásánál soha ne rakjunk aposztrófokat, hiszen a változók értékeit akarjuk kiíratni (tehát azt, amit tartalmaznak és nem a formájukat).

Feladat: Van három integer típusú változónk. Állapítsuk meg, mit csinál a következő programrész az a és b változók értékeivel, ha azt beírjuk az előző programba az értékadások után, a program végére. Ne feledjük el a deklarációt is kiegészíteni! :

x:=a;
a:=b;
b:=x;

Megoldás: A programrész felcseréli a és b változók értékeit. Vegyük tehát az előző példát. A beírt programrész lefutása előtt az a=8 és a b=6 értékkel rendelkeztek. Ekkor fenti a programrész a következőt fogja tenni:

1.      Az első sor az a változóban levő értéket berakja az x változóba. Tehát az első sor lefutása után az a, b értéke változatlan, az x értéke pedig ugyanaz, mint az a változó értéke (tehát a=8, b=6, x=8).

2.      A második sorban a b változó értékét raktuk bele az a változóba (tehát a=6, b=6, x=8). Így az a változóban levő eredeti értékünk elveszett, de mivel az első sorban ezt beraktuk az x változóba, ezért ott még megvan.

3.      A harmadik sorban az x változóból raktuk át (vissza) az értékét a b változóba (tehát a=6, b=8, x=8).

Így valójában az a és b változó értékét felcseréltük. Az x segédváltozóra azért volt szükségünk, hogy ebben megőrizzük az a értékét mielőtt az a-ba beleraktuk volna a b értékét, ami azt felülírta. Végül ebből az x változóból raktuk vissza a megőrzött értékét b változóba. (Na, kedves 10.c osztályos tanuló, egy ilyen, munka is csak  egyszer, egyetlen egyszer, egy feladat formájában foglalkozik a változók cseréjével. Gondold csak el, mi mióta foglalkozunk vele!? Neked megy már?)

 Végül lássunk egy példát, melynél ugyanabba a változóba teszünk előbb 25-öt, aztán a 17-et, majd értékét csökkentjük 8-cal. Ellenőrzésképpen, amikor a k változónak új értéket adunk, kiíratjuk a változó értékét a képernyőre. Megfigyelhetjük, hogy a k változó értéke mindig csak az utoljára kapott érték lesz (ez előtte belerakott szám elveszik).

program Pelda07;
var k:integer;
begin
 k:=25;
 WriteLn('A k valtozo erteke: ',k);
k:=17;
 WriteLn('A k valtozo erteke: ',k);
 k:=k-8;
 WriteLn('A k valtozo erteke: ',k);
end.

A futtatást próbáld ki!

     Megjegyzés: amíg egy változónak nem adunk a programban semmilyen értéket, addig az értéke integer típusú változó esetén: 0, string típusú változó esetén pedig üres szó. Ez azonban csak a Pascal nyelvben igaz, más programozási nyelvekben a változó kezdeti értéke nincs meghatározva, ami annyit jelent, hogy értéke kezdetben bármi lehet. Tehát, egy változó első művelete mindig az értékadás legyen! (Próbáld ki értékadás nélkül a kiírást, de aztán ezt felejtsd el, nem fogom elfogadni KIL) Értéket a változó billentyűzetről is kaphat, vagy egy eljárásban is adhatunk neki értéket.