Változók, avagy dobozok minden esetre

Ismerkedjünk meg a változókkal. A változóknak alapvetően két típusát különböztetjük meg: egyszerű (primitív) és összetett típusok. Az összetett típusú változók nem egy egyszerű értére mutatnak, hanem egy komplexebb adatszerkezetre, amely egyszerű típusok használatával épül fel. Maga a változó csak egy hivatkozás az adatszerkezet memóriabeli címére. Most a primitív változókat fogjuk tárgyalni.

A programunkban szinte mindig előfordul az, hogy valamilyen adatot tárolni szeretnénk. Nyilván ezeknek a tárolóknak egyedieknek kell lenni, mindegyik a többiektől függetlenül tartja nyilván a benne tárolt értéket. Ezeket a tárolókat változóknak nevezzük. A nevük arra utal, hogy minden időpillanatban egyetlen értéket tárolnak, de ez az érték változhat. Ha új értéket adunk neki, akkor az előző érték törlődik. A változók megadásakor két fontos dolgot kell rögzítenünk. A benne tárolandó érték típusát, és a tároló egyedi nevét. A változó a háttérben valójában egy memóriaterület, ami valamilyen értéket tárol. Felsorolásképp foglaljunk össze pár fontos megállapítást a változókkal kapcsolatban:

• A változók neve egyedi kell hogy legyen (adott blokkon belül), csak betűvel kezdődhet, de utána bármennyi és bármilyen karakter állhat.
• A változók értéke alapvetően nem fix, ezt módosíthatjuk, erre utal a változó név. (léteznek fix változók is, melyek értékét csak egyszer adhatjuk meg.)
• Minden változó egy időpontban egyetlen értéket tárolhat. Ha új értéket adunk neki, az előző érték törlődik.

A változó neve a programunkon belül minden esetben a benne tárolt értéket jelenti. Ahol a változó nevét a programba illesztjük, ott az abban tárolt értéket fogja felhasználni. Említettem, hogy a változó típussal, névvel és értékkel rendelkezik. Ebből a típusról nem volt még szó. A típus azt határozza meg, hogy milyen jellegű értéket tárolhatunk az adott változóban. A primitív változók alapvetően négyféle típusúak lehetnek, egy-egy konkrét példával:

• egész szám: 32
• valós szám: 1.125
• karakter: c
• logikai érték: true

Ezek az alaptípusok, de az egész és valós számok váltózói a bennük tárolt szám nagyságától függően még tovább bonthatók, valamint számok esetén még az is megadható, hogy előjeles-e az adott szám, vagy csak pozitív értékeket tárolhat. Az egész számok egész értékeket tárolnak tizedesjegyek nélkül. A valós számok tizedesjegyekkel rendelkező számokat jelentenek. A karakter típusú változó valamilyen billentyűzeten lévő begépelhető karaktert tárolhat (betűk, számok, írásjelek, speciális karakterek, szóköz, stb), valamint speciális, önmagában be nem gépelhető vezérlő karaktereket tartalmazhat. A logikai érték pedig egy kétállású kapcsoló, mely igaz vagy hamis értékeket tárolhat, pontosabban ezek angol nyelvű megfelelőjét (true, false).

A változó tehát egy típussal, névvel és a típus által meghatározott értékkel rendelkező adatelem. Nézzünk a változók használatára egy példát. A programunk modellezzen egy autót, és rendelkezzen pár tulajdonsággal. Legyen az autónak sebességfokozata, pillanatnyi sebessége, színkódja, és egy jelző, ami a színkódot bővíti ki, hogy metálfényű-e vagy sem. Ebben a példakódban mind a négy alaptípus megtalálható.

#include <iostream>

using namespace std;

int main()
{
    int fokozat;
    double sebesseg;
    char szinkod;
    bool metal;

    cout << "Ez egy virtualis auto." << endl;
    fokozat = 4;
    sebesseg = 48.6;
    szinkod = 'R';
    metal = true;

    cout << "Az auto sebessegfokozata: " << fokozat << endl;
    cout << "Az auto pillanatnyi sebessege: " << sebesseg << endl;
    cout << "Az auto szinkodja: " << szinkod << endl;
    cout << "Az auto metalszinu: " << metal << endl;

    return 0;
}

A változók használatával kapcsolatban két nagyon fontos fogalmat kell tisztázni:

• deklarálás
• inicializálás

A deklarálás a változó típusának és nevének megadását jelenti. Ennek általános formája:
típus változónév;
Az inicializálás a változónak történő kezdőérték adás. Általános formája:
változónév = kezdőérték;
Ez a két lépés akár össze is vonható, ekkor a következőt írjuk:
típus változónév = kezdőérték;

A változók tekintetében fontos ügyelni arra, hogy addig ne használjuk a változót, amíg nem rendelkezik kezdőértékkel, ami akár nulla vagy típustól függően speciális null (üres) érték is lehet. Használatnak minősül az is, ha a változó értékét ki szeretnénk íratni a képernyőre. A változó értékét természetesen többször is meg lehet változtatni, ilyenkor az előző érték, mint már említettem, törlődik. Ez az értékadás formailag ugyanolyan, mint az inicializálás. A különbség a kettő között csak annyi, hogy az inicializálás a legelső értékadás.

Ahogy már említettem, a változó nevét használva a benne tárolt értéket kaphatjuk meg. Amikor például ki szeretnénk írni, hogy milyen értéket tárol, akkor a következőt tesszük:

cout << "Az auto sebessegfokozata: " << fokozat << endl;

Az idézőjelek közötti szövegrészt string-nek nevezzük. Ez egy karakterekből álló karakterlánc (szövegnek is nevezik, bár nem csak betűket tartalmazhat). A string összetett változótípus, később fogjuk tárgyalni, most elég annyit tudni róla, hogy amit idézőjelek közé teszünk, az string típusú lesz. Azért fontos ez, mert jellemzően szövegeket írunk ki a képernyőre. Láthatjuk, hogy a szöveges kimenethez a < < jelekkel hozzáfűztem a változó értékét.

Még a primitív változóknál is léteznek adott típuson belül különféle “méretű” tárolók. Attól függetlenül, hogy egy változó mondjuk egész számokat tartalmazhat, meg lehet adni a méretét is. A mérete alatt azt értjük, hogy a számítógép hány bájton tárolja a szám értékét, ezáltal meghatározza azt az intervallumot, amekkora értéket a változó felvehet. Egész típuson belül a következő állnak rendelkezésünkre:

Vigyázz, a long és int típusok azonos méretűek! Más nyelvben, mondjuk a Java nyelvben a long 8 bájt méretű. Itt a long long típusú változó az, amely nagyobb méretű, mint az int.

Az egész típusokhoz hasonlóan lebegőpontos számokat tartalmazó változóból is többféle, szám szerint kettő van.

Mivel azonos típusból többféle méret létezik, már a kezdőérték megadásakor problémák lehetnek. Vegyük ezt a példát:

int szam = 10;

Ezzel semmi gond nincs, ugyanis az int típusba ez a méretű szám elfér. A short típusnál is hasonlóan lehet megadni kezdőértéket, arra kell csak ügyelni, hogy megfelelő méretű számot tároljunk csak benne. Az utolsóval már gond lenne, mert a tárolni kívánt érték már nincs benne a változónak megfelelő intervallumban.

1. short s = 10;
2. short s = -40;
3. short s = 120;
4. short s = 35000;

A változók, mint adott méretű tárolók természetesen csak a nekik megfelelő méretű számokat képesek tárolni. A nagyobb méretű tárolókba elhelyezhetjük egy kisebb méretű változó értékét, de fordítva ezzel nagyon kell vigyázni. Próbáld ki az alábbi kódot.

int i = 35000;
cout << i << endl;
short s = i;
cout << s << endl;

Láthatod, hogy az int, vagyis a nagyobb méretű változó tartalmát gond nélkül belerakhatod, egy kisebb tárolóba, de mindenféle figyelmeztetés nélkül a kisebb változóban nem az az érték lesz, hiszen nem fér bele. Ekkor úgynevezett túlcsordulás jön létre, vagyis valami teljesen más érték lesz a változóban. Erről csak akkor értesülhetsz, ha véletlenül kiszúrod a program kimenetében. Ha efölött elsiklasz, akkor sokáig törheted a fejed, hogy mi a gond.

Összefoglalva tehát az egész számokat:

• többféle méretű típusa létezik
• nagyobb méretű típusba be lehet tenni a kisebbet, fordítva nem biztos, hogy belefér

Lebegőpontos számok esetén a különbség a két szám között gyakorlatilag a tizedesjegyek számában van. A double egy nagyobb pontosságú lebegőpontos, vagyis valós szám. A float méretű valós szám nagyjából 6-7 tizedes jegyig pontos, a double méretű pedig 15 jegyig. Nekünk a tanulmányaink során a double méret teljesen megfelelő lesz. Arra azonban figyelni kell, hogy ha mégis float méretű változót használnánk, akkor ügyeljünk arra, hogy 7-8 tizedes jegytől kezdődően megbízhatatlan a pontossága.

Következő lecke: Kiíratás alapjai