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
szerkesztésItt 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
szerkesztésA 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
szerkesztésMinden 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
szerkesztésA 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
szerkesztés
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 ) 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
szerkesztés
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
szerkesztés
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
szerkesztésA 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·1023 é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
szerkesztésUtasításblokkok
szerkesztésTö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
szerkesztésÉ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.)