Az eddigi programjaink csak kiírni tudtak. Jó lenne interaktívvá tenni őket, és megírni olyanra, hogy adatokat is tudjanak fogadni. Adatok fogadásához szükségünk van valamire, ami tárolni tudja őket. Ezt a tárolót a programozásban változónak nevezzük. Azért változónak hívják ezt a tárolót, mert tartalma a program futása során változhat. (Én ezentúl a ”változó” kifejezést használom a ”tároló” helyett.)
A válozót úgy kell elképzelni mint egy dobozt, amibe bizonyos dolgokat rakhatunk. Olyan dolgokat, ami beleillik és belefér.
Képzeljünk el egy polcot. Ezen az polcon van néhány, különböző méretű doboz. Az egyik doboz például a fényképezőgépünk doboza, csak a fényképezőnk illik bele, mert van benne egy fröccsöntött műanyag ami a fényképező formájúra van alakítva. A másik doboz a webkameránk doboza. Ez apró, kicsi, szabályos téglatest alakú. A harmadik pedig a nyomtató nagy, üres papírdoboza.
A változók is hasonlóan helyezkednek el a memóriában. A polc felel meg a számítógép memóriájának, a dobozok pedig a változóknak, amibe rakhatunk valamit. Némelyik dobozba csak beleillő tárgyakat pakolhatunk, mert ”van bennük fröccsöntött műanyag” - némelyik dobozba pedig más is belefér. Például egy kisebb doboz. A változók is pont így működnek. Ezzel a feledtébb buta hasonlattal a változók típusára és méretére akartam utalni :)
Egy változóról meg kell mondani a típusát, azt, hogy mit pakolhatunk bele.
Kezdjük a legegyszerűbb változóval, ami egy egész számot tud tárolni. Az egész szám angolul integer, egész szám típusú változót az int kulcsszóval hozhatunk létre. A változót el is kell valahogyan nevezni. Ezzel a névvel hivatkozhatunk rá a későbbiekben, amikor el akarjuk érni és meg szeretnénk nézni mi van benne. Én például létrehozok egy egész szám tárolására képes ”dobozka” nevű változót:
#include<stdio.h>
int main() {
int dobozka;
return 0;
}dobozka.c c
A dobozkában még nincs semmi. Pontosabban memóriaszemét van benne.
A számítógép memóriáját intenzíven használják az alkalmazások. Ha egy alkalmazás befejezte a futását, akkor vagy ő vagy az operációs rendszer felszabadítja az eddig általa használt memóriaterületet. Ez nem abból áll, hogy a rendszer szépen kitakarítja ezt a területet felmosóronggyal esetleg felülírja csupa nullával, hanem úgy hagyja ahogy van. Rumlisan. Majd a következő program, aki használni szeretné ezt a területet ő elintézi a kezdeti rendrakást. Tehát amíg mi, programozók ”rendet nem rakunk” ezen a területen, addig az előző alkalmazás szemetét, az általa otthagyott dolgokat olvashatjuk. Ez teljesen véletlenszerű adat.
Úgy tudunk rendet rakni, hogy feltöltjük ezt a területet valamivel, például egy számmal. Ezt nevezik a változó inicializálásának. Írjunk egy egyenlőségjelet a változó neve után, és adjunk neki értéket.
#include<stdio.h>
int main() {
int dobozka = 5;
return 0;
}inicializal.c c
Bármennyi változót létrehozhatunk, bármilyen névvel. Pár dologra azonban ügyelni kell:
-
Egy változó neve állhat az ABC betűiből, számokból, és aláhúzásjelből.
-
Változó neve nem kezdődhet számmal.
-
A C nyelv kis -és nagybetűérzékeny, a kis és nagybetűkkel írt szavakat megkülönbözteti. Például létrehozhatunk változót dobozka, Dobozka, DoBoZkA és DOBOZKA néven is, egyszerre, ezeket különbözőnek érzékeli a C. Fontos megjegyezni, hogy a kis- és nagybetűérzékenység, angol nevén case sensitivity nem csak a változónevekre, hanem az egyéb kulcsszavakra is érvényes. Ezért nem írhatjuk például nagybetűvel a Main-t, vagy a #include-ot, mert így nem működne.
-
Változó neve nem lehet foglalt szó. A foglalt szavak listáját alul olvashatod. Ezek olyan nyelvi elemek, amiket nem lehet használni programozás során, mert más programszerkezetek használják őket:
Hozzunk létre még egy változót, ”rekesz” néven, kezdeti értéke legyen 2!
#include<stdio.h>
int main() {
int dobozka = 5;
int rekesz = 2;
return 0;
}rekesz.c c
Változó kiíratása, hely-jelölők.
Már szinte mindent tudunk az egész szám változókról. Ideje kezdeni is velük valamit. Például írjuk ki a dobozka változót a képernyőre. A kiírást a printf (); paranccsal végezhetjük el úgy, hogy a kiírandó szövegben (az idézőjelek között) elhelyezünk úgynevezett hely-jelölőket, és a szöveg után felsoroljuk a kiírandó változókat. Huh, érthetetlen mi? Lássunk egy példát.
#include<stdio.h>
int main() {
int dobozka = 5;
int rekesz = 2;
printf("A rekeszben %d van.", rekesz);
return 0;
}kiiras.c c A rekeszben 2 van.
A %d egy hely-jelölő. Ez, mint egy székfoglaló foglalja a rekesz változó helyét a mondatban. A hely-jelölők – csakúgy, mint a vezérlőkarakterek – vezérlő szerepet töltenek be. A helyükre helyettesítődik be egy adott változó értéke. Az egész szám (int) típusú változókhoz a %d hely jelölő tartozik. A későbbiekben más típusú változókat is megismerünk, például valós számokat, karakterket... és megtanuljuk a hozzá tartozó hely-jelölő karaktert is.
A printf parancsnak itt most két paramétere van. Az első paraméter idézőjelek között a kiírandó szöveg. Ennek hivatalos neve formátumsztring, mert megadja a kiírás formátumát. Ezért is áll a print szó után mégegy f betű is (printf), mert a szövegben több hely-jelölőt is elhelyezhetünk, megadva ezzel egy formátumot.
Írjuk ki a dobozka tartalmát is!
#include<stdio.h>
int main() {
int dobozka = 5;
int rekesz = 2;
printf("A rekeszben %d van a dobozban %d van.", rekesz, dobozka);
return 0;
}kiiras2.c c A rekeszben 2 van a dobozban 5 van.
Az idézőjelek közötti formátumsztring részbe hely-jelölőket raktunk, és a formátumsztring után felsoroltuk a változókat. Arra figyeljünk, hogy pontosan annyi változót kell felsorolni, ahány hely-jelölő van a szövegben.
Műveletek változók között
A változók között műveleteket végezhetünk. Összeadhatjuk őket (+), kivonhatjuk őket egymásból (-), szorozatunk (*), oszthatunk (/) és maradékosan is oszthatunk (%). Ezeket a műveleti jeleket úgy hívják, hogy operátorok, mert valami operációt, műveletet végeznek. A C nyelvben sok más operátor van, amiket kategóriákba sorolhatunk. (aritmetikai operátorok, logikai operátorok, összehasonlító operátorok...) Ezeket szépen fokozatosan ismerjük meg.
A műveletvégzés során egy művelet két részre osztódik:
-
A művelet egyik része megmondja, hogy hova rakjuk az eredményt. Ez mindig az egyenlőségjeltől balra helyezkedik el, ezért a neve: balérték
-
A másik része pedig maga a művelet, ami mindig a egyenlőségjeltől jobbra van, ezért a neve: jobbérték
Adjuk össze a két változót!
#include<stdio.h>
int main() {
int dobozka = 5;
int rekesz = 2;
dobozka = dobozka + rekesz;
printf("A rekeszben %d van a dobozban %d van.", rekesz, dobozka);
return 0;
}osszead.c c A rekeszben 2 van a dobozban 7 van.
Itt a balérték, amibe az eredmény kerülni fog, a dobozka változó. Az egyenlőségjeltől jobbra pedig a jobbérték terül el, maga a művelet, ami ad egy eredményt. 5 + 2 = 7. A dobozkába a 7-es szám kerül, a rekeszben marad a 2.
Túrjunk a szemétbe!
Hozzunk létre egy "A" nevű változót. Létrehozáskor ne adjunk neki kezdőértéket, hanem egyből írassuk ki a tartalmát.
Vigyázzunk arra, hogy a változó nevét mindenütt nagy betűvel írjuk, mert a C nyelv case sensitive! Mit látunk? Egy véletlen számot. Ezt egy régebben futó program hagyta a memóriában, és mi nem írtuk felül semmivel, ezért jelent meg a konzolablakon.
#include<stdio.h>
int main() {
int A;
printf("%d", A);
return 0;
}memoriaszemet.c c 5273
A műveletek végigpróbálása
#include<stdio.h>
int main()
{
int a = 5, b = 3, e;
e = a + b; printf("osszeadas %d \n", e);
e = a - b; printf("kivonas %d \n", e);
e = a * b; printf("szorzas %d \n", e);
e = a % b; printf("maradekos osztas %d \n", e);
e = a / b; printf("osztas %d \n", e);
return 0;
}muveletek.c c osszeadas 8 kivonas 2 szorzas 15 maradekos osztas 2 osztas 1
A C nyelvben engedélyezett az, hogy egyszerre több egész szám változót hozzunk létre egyetlen int kulcsszóval. Ilyenkor a változókat vesszővel választjuk el egymástól. Nem kötelező mindegyik változónak értéket adni, itt például az eredményváltozó a létrehozáskor nem kap kezdeti értéket, de ez nem baj, mert műveletvégzéskor úgyis kerül bele egy szám, és felülíródik az eredetileg benne lévő memóriaszemét.
Minden sor elején olvasható egy művelet, a sor végén pedig ennek a műveletnek az eredménye. A %d hely-jelölő helyére helyettesítődik be az ”e” eredmény változó értéke. Mivel nem egy sorba összefolyt kimenetet szeretnénk látni a konzolablakban, ezért a printf kiíró parancs végére még egy \n vezérlőkaraktert is célszerű beszúrni, hogy a kiírás új sorban folytatótjon.
A program elején csak 3 darab változót hoztunk létre, 3 darab tárolónk van a memóriában amibe egész számokat rakhatunk. Ezekkel kell gazdálkodni. A kódban ugyan többször is szerepel a bal oldalon az ”e” eredmény változó, de ez nem azt jelenti, hogy ilyen sok példány jött létre a memóriában belőle. A műveletek és kiírások egymás után hajtódnak végre, és ez esetben minden egyes új művelet eredménye az ”e” változóba kerül, felülírva az ott kuksoló régi eredményt.
A + - * és / operátorok használatát még egy földigiliszta is megérti – a maradékos osztás, hivatalos nevén modulo-val azonban gondok lehetnek. A diákok gyakran összekeverik a % műveleti jelet a printf parancson belül használatos %-kal kezdődő hely-jelölőkkel. Ez a kettő nem ugyanaz, erre figyelni kell!
De mi is pontosan az, hogy modulo?
a % b = x
Ejtsd: ”a” modulo ”b” eredménye x. Ha az ”a”-t elosztjuk ”b”-vel, akkor x-et kapunk maradékul. Például: 10 % 3 = 1, mert tízben a három meg van háromszor, maradt az 1. Vagy: 6%3=0, mert hatban a három megvan kétszer, nem maradt semmi.
A műveletes programnak minden eredménye hibátlan? Nem. Az osztás hibás eredményt adott. Mi a tök? Az egy olyan naaagy ízletes zöldség.
A következő fejezetben kiderül, hogy miért hibás az osztás!
