C programozás/Változók

Mint a legtöbb programozási nyelv, a C képes névvel ellátott változók és azok tartalmának használatára és feldolgozására. A 'változók csak nevek, amelyek a memória egy helyére hivatkoznak - arra a helyre, amely azt az értéket tárolja, amire hivatkozunk.

Hasznos, ha úgy gondolunk a változókra, mint az értéket helyettesítő névre. Úgy gondolhatunk a változóra, mint ami egyenértékű a hozzá tartozó értékkel. Tehát, ha van egy i változó, amelyiket 4-es értékkel hoztunk létre (4-es értékkel inicializáltunk), abból következik, hogy az i+1 az 5 lesz.

Mivel a C viszonylag alacsony színtű programozási nyelv, mielőtt egy C program használni tud egy memóriaterületet egy változó tárolására, igényelni kell azt. Ezt a változó deklarálásával tehetjük meg. A változó deklarálása az a folyamat, amikor a C programnak megadjuk, hogy hány változó legyen, mi legyen a nevük és mekkora memóriaterületre van szükségük az egyes változóknak.

A C programozási nyelvben, amikor változókkal dolgozunk, fontos tudni a változó típusát és méretét. Mivel a C egy elég alacsony szintű nyelv, ezek hardver-specifikusak lehetnek - azaz, az hogy hogyan működik az egyik gépen, különbözhet attól, hogy hogyan működik egy másikon.

A C nyelv összes változóját csak a deklaráláskor megadott típus tárolására használhatjuk.

Deklarálás, inicializálás és értékadás

Itt egy példa egy egész típusú változó deklarálására. Ezt a változót egy_szam néven fogjuk nevezni. (Fontos a sor végi pontosvessző; a fordító ilyen módon választja el egymástól a program egyes utasításait.)

int egy_szam;

Ez az utasítás azt jelenti, hogy az egy_szam nevű változó számára annyi helyet foglaltunk a memóriában, ami egy egész típus (integer) típusú változó tárolására elegendő. Fontos, hogy meg kell adni az adat típusát, amelyet a változó tárolni fog. Speciális kulcsszavak vannak a típusok megadására - ezt a következő fejezetben fogjuk látni.

Több változó is deklarálható egyetlen utasításban a következőképpen:

int egy_szam, masik_szam, megegy_szam;

Azt is megtehetjük, hogy deklaráljuk a változót és rögtön értéket adunk neki.

int egy_szam=3;

Ezt hívják initializálásnak.

A C korai verzióiban a változókat a blokkok elején kellett deklarálni. A C99-ben (a C 1999-es verziójában) megengedett a deklarálások és az egyéb utasítások keverése - de nem gyakran használják, mert ritkán szükséges, és néhány fordító még nem támogatja a C99-et.

Miután deklaráltunk egy változót, értéket adhatunk a változónak egy alábbihoz hasonló utasítással:

egy_szam=6;

Egy változónak akárhányszor értéket adhatunk, ezért is hívják változónak.

Egy változónak egy másik változó értékét is átadhatjuk:

  
egy_szam = masikszam;

Vagy több változónak ugyanazt az értéket adhatjuk egyetlen utasítással:

egy_szam = masikszam = megegyszam = 3;

Ez azért működik, mert az x = y értékadás a változóhoz rendelt értékkel tér vissza. Az x = y = z valójában egy rövidítése a x = (y = z) utasításnak.

Változók elnevezése

A C-ben a változónevek betűkből (ékezet nélküli nagy- és kisbetűk) és számokból állnak. Az aláhúzás karakter ("_") is megengedett. A nevek nem kezdődhetnek számmal.

Alább látható pár érvényes változónév:

oszto
Nevek
URL
szemelyi_szam
_alma
_
JeloloBizottsag

Pár példa érvénytelen nevekre:

7szilvafa    (számmal kezdődik)
legnagyobb kozos oszto  (szóköz nem megengedett nevekben)
$koltseg    ($ nem megengedett -- csak betűk, számok és _)
while   (a nyelv kulcsszavai nem használhatóak változónévnek)

Ahogy az utolsó példa mutatja, bizonyos szavak le vannak foglalva a nyelv kulcsszavai számára, és ezeket nem használhatjuk változónévként. Ilyenek például az if és a for is. Érdemes betartani, hogy az aláhúzással kezdődő változóneveket nem használunk.

A C változóneveinek szabályai érvényesek egyéb nyelvi konstrukciók, mint a függvénynevek, struktúrák tag-jei és makrók esetén is; ezekről később lesz szó.

Literálisok

Minden esetben, amikor a programban egy értéket közvetlenül adunk meg ahelyett, hogy egy változóra hivatkoznánk, vagy egyéb más módon, az értéket literálisnak nevezzük. A fenti inicializálási példában a 3 egy literális.

A négy alapvető adattípus

A C szabványban négy alapvető adattípus van. Ezek az int, char, float és double.

Itt röviden leírjuk ezeket. Bővebben a C programozás/Típusok fejezetben lesz szó róluk.

Az int típus

Az int típus egész számokat képes tárolni. Egy egész értéke tipikusan a számítógép szavának méretével egyezik, amely a legtöbb modern személyi számítógépben 32 bits (4 byte) vagy 64 bit (8 byte). A következők példák egész literálisokra: 1,2,3, 10, 100... Ha az int 32 bites, minden egész számot képes tárolni -2147483648 és 2147483647 között. Egy 32 bites szám 4294967296 (azaz $2^{32}$) lehetőséget képes tárolni.

Ha új egész változót szeretnénk használni, az int kulcsszót használjuk. Például:

int hallgatok_szama, i, j=5;

Ekkor három változót deklarálunk, továbbá a j-nek az 5 literális értéket adjuk.

A char típus

A char típus képes tárolni a végrehajtás karakterkészletének bármelyik elemét. Olyan adatot tárol, mint az int, de tipikusan egy byte méretű. A legtöbb implementáció az ASCII karakterkészletet használja a végrehajtás karakterkészleteként.

Példák karakterliterálisokra 'a', 'b', '1', stb, valamint néhány speciális karakter, mint a '\0' (a null karakter) és '\n' (újsor, emlékezzünk a "Hello, Világ" példára). Vegyük észre, hogy a char értéknek egyszeres idézőjelben kell lenniük.

Egy példa az inicializálásra:

char betu1 = 'a';

A float típus

A float a floating point, azaz lebegőpontos szám rövidítése. Valós számokat tud tárolni, de csak a egy gépi szó méretben. Ezért akkor használjuk, hogy nem szükséges a double által elérhető pontosság. A float literálisok végére F vagy f betűt kell írni, másképpen double-ként kerülnek értelmezésre. Példák: 3.1415926f, 4.0f, 6.022e+23f. A float változók a float kulcsszóval deklarálhatóak.

The double type

A double és a float típusok nagyon hasonlóak, de a double kétszeres pontossággal képes tárolni a számokat – valós számokat, vagyis egész és tört számokat. Példák double literálisra 3.1415926535897932, 4.0, 6.022e+23. Az utolsó példa normálalakot használ, azaz 6,022·10²³ értéket jelent. Ha 4-et használunk 4.0 helyett, azt egészként (int típusként) értelmezi a program.

A double változók a double kulcsszóval deklarálhatóak:

double ket_pi = 6.2883185307179586;

(Az angol változatnak itt még nincs vége. Az alábbi rész az angol változatban egy korábbi fejezetben található.)

Utasításblokkok és a változók hatáskörei

Utasításblokkok

Több utasítást elhelyezhetünk egy utasításblokkban. Ekkor az utasítások elé nyitó kapcsos zárójelet "{", utánuk záró kapcsos zárójelet "}" kell rakni. Általános szabály, hogy egy C programban ahol egy utasítás állhat, ott mindig lehet utasításblokk is. Erre általában akkor van szükség, ha egy ciklusmaghoz, a feltételes elágazás egyik ágához több utasítás tartozik.

Egy példát már láttunk utasításblokkra. A main függvény utasításait utasításblokkba helyeztük, ahogy a függvények esetén szükséges. Később a vezérlési szerkezetek fejezetben megismerjük a ciklusokat. Ezek gyakran egyetlen utasítást ismételgetnek majd:

for (i=0; i<20, i++)
  printf("Sokszor kiírom.\n");

Itt a ciklusmag egyetlen utasítása a printf függvény meghívása. Ha viszont a ciklusmagba több utasítás tartozik, akkor utasításblokkra van szükségünk. Ez nem csak for-ciklusnál működik: a kapcsos zárójel jelzi, hogy meddig tart a függvény definíciója, a ciklus magja, a feltételes elágazás valamelyik ága.

A következő példában egynél több utasítás tartozik a for-ciklushoz, ezért szükséges az utasítások blokkba (kapcsos zárójelek közé) zárása:

for (i=1; i<20, i++)
{
  printf("%d. alkalom", i) 
  printf("Sokszor kiírom.\n");
}

(A printf karakterláncában a %d helyére fog beíródni az i változó értéke. A kiíratásról a Kiíratás és beolvasás fejezetben lesz bővebben szó.)

Mindig fontos figyelni arra, hogy a kapcsos zárójelek párosan szerepeljenek: minden utasításblokk le legyen zárva.

A változók hatáskörei

Értékeket változókban tárolhatunk. Ekkor először deklarálni kell a változót, azaz meg kell adni a típusát. Ezután értéket adhatunk a változónak, majd kiírathatjuk a printf utasítással:

#include <stdio.h>

int main(void)
{
  int i;
  i = 8;
  printf("%d\n", i);
}

Egy változó hatásköre azt a szintet jelzi, ahol a változó látható. Egy utasításblokkban deklarált változó csak az utasításblokkon belül lesz elérhető. Utasításblokk tartalmazhat újabb utasításblokkot is. A belső utasításblokkban deklarált változók a külsőben nem érhetőek el.

/* a main függvény */
int main(void)
{
    /* Ez a main függvény definíciójának a blokkja */

    int i; /* ezt a külső blokkban deklaráltuk */
    i = 6;
    {
        /* ez egy új blokk új hatókörrel */

        /* ez is egy i változó, de mivel egy új blokkban van,
           nem befolyásolja a külső blokk i változójának értékét. */
        int i;
        i = 5;
        printf("%d\n", i); /* 5-öt ír ki a képernyőre */
    }
    /* visszatértünk a külső blokkba */

    printf("%d\n", i); /* 6-ot ír ki a képernyőre */

    return 0;
}

A C-ben kétféle hatáskör van. Azt mondjuk, hogy egy változó globális, ha egy változó a program tetszőleges helyén látható és módosítható. Akkor mondjuk, hogy egy változó lokális ha csak abban a blokkban elérhető és módosítható a változó, amelyben létrehozták. Az alábbi példában a main függvényen kívül deklarált i és j változó globális lesz, a belül deklarált i változó lokális.

int i =  5; /* ez globális változó, a programban akárhol elérhető */
int j = 15; /* ez is */

/*
Ez egy függvény.
Az összes benne definiált változó lokális, csak a függvényben érhető el.
*/
int main(void)
{
    int i = 6; /* 'i' most 6 */
    printf("%d\n", i); /* kiírja a lokális 6-ot a globális i változó 5-ös értéke helyett */
    printf("%d\n", j); /* kiírja a 15-öt, a globális változó értékét */

    return 0;
}

(A példában a változók deklarálásakor rögtön kezdőértéket is adtunk neki.)