A bc program használata - 1. rész

Most egy kicsit előre megyek, és bemutatok egy konzolos programot. Aki nem érti ezt a cikket, az nyugodtan ugorja át. A következő már visszatér az alapokhoz.

Ez a konzolos program nem más, mint a bc. Futtatni nagyon egyszerű, csak be kell írni terminálba, hogy bc, és már fut is, bár ez a konzol villogásán kívül semmiben sem nyilvánul meg. Tegyünk vele egy próbát, és írjuk be, hogy:

13+37

Az eredmény egyből meg is jelenik. Próbáljunk ki most valami érdekesebbet:

(13+37)^(2*4)

Az eredmény (15625) ezúttal is megjelenik. Az eddigi bevezetőből nyilván mindenki rájött már, hogy egy konzolos számológéppel van dolgunk. De ez nem egy közönséges számológép! Ezt lehet programozni is. (Innentől feltételezek egy alapvető programozói tudást.) Nézzük meg a lehetőségeit közelebbről!

Ezt űgy tudjuk megtenni, ha először is beírjuk, hogy quit (vagy nyomunk egy [CTRL]+C-t és megtudjuk, hogy ezt kell beírni) és kiadjuk a bashnak a következő parancsot:

man bc

Ebből megtudhatjuk, hogy a bc egy komplett u.n. interpreter (magyarul parancsvégrehajtó), ami elsősorban numerikus műveletek elvégzésére alkalmas.

Két adattípussal rendelkezik: skalárral és tömbökkel. A skalárok rendelkeznek két további tulajdonsággal: A mérettel (vagyis hogy hány számjegyből állnak) és a pontossággal (vagyis hogy a tizedes pont után hány számjegy állhat.)
A paramétereket nem kell előre deklarálni, azok maguktól létrejönnek, amint hivatkozunk rájuk.
Nézzünk egy példát a skalárok használatára:

a
> 0
a=10
b=20
a+b
> 30
a*b
> 200
b^a
> 10240000000000
c=a+b
c
> 30

Remélem, a lényeg kivehető a fenti példából, ezért nem is nagyon magyarázom, hogy mi miért történt. (Csak annyit, hogy a >-jeleket én raktam be, és azt jelentik, hogy ott nem én írtam be, hanem ő írt ki.)

Térjünk át egy izgalmasabb adatszerkezetre: a tömbökre.
A tömbök (pongyolán fogalmazva) nem mások, mint sok skalár ugyan azzal a névvel. Indexeléssel hivatkozunk az egyes elemekre. A bc az indexelést is dinamikusan kezeli, tehát nem kell előre lefoglalni a memóriában a megfelelő méretet. Magyarázhatnám még a működésüket, de ezt is példán keresztül lehet a legjobban megérteni.

tomb=10
tomb[0]
> 0
tomb[1]
> 0
tomb[0]=10
tomb[0]
> 10
tomb[1]=20
tomb[1]
> 20
tomb[0]
> 10
tomb[3]=tomb[0]+tomb[1]
tomb[3]
> 30
tomb[132]=3.14
tomb[131]
> 0
tomb[132]
> 3.14
tomb[133]
> 0
tomb
> 10

Az egydimenziós tömbökről (másként vektorokról) ennyi elég is. Többdimenziós tömböket a bc nem képes támogatni, de egy későbbi cikk keretében fogok hozzá írni egy olyan könyvtárat, mely tetszőlegesen sok dimenziós tömböket is tud majd kezelni. Most inkább térjünk át az első fejezet befejezésére: a ciklusokra.

Ehhez először is beszélni kell a logikai műveletekről. Ezek olyan műveletek, melyek visszatérési értéke 1 (igaz) vagy 0 (hamis).
Ezt is inkább példákon keresztül mutatom be:

1<2> 1
2<1> 0
2==2
> 1
3==2
> 0
a=3==2
a
> 0
a=2<4> 1

És most jöjjenek is a ciklusok.

while (feltétel) {
ciklustörzs
}

A ciklustörzs addig hajtódik végre, amíg a feltétel logikai értéke igaz (vagyis 0-tól különböző).

for (kifejezés1; kifejezés2; kifejezés3){
ciklustörzs
}

Ez a C-típusú nyelvekből ismert szabvány for-ciklus. Először végrehajtódik a kifejezés1, aztán ha a kifejezés2 értéke igaz, akkor lefut a ciklustörzs, majd a kifejezés3. Ezután újra ellenőrzi a kifejezés2-t, újra lefut a ciklustörzs és így tovább, amíg a kifejezés2 igaz.

Végül bemutatom az elágazást.

if (feltétel) {
igaz_ág;
} else {
hamis_ág;
}

Itt a feltétel kiértékelődik, ha igaz, akkor lefut az igaz ág, ha hamis, akkor a hamis_ág fut le. A hamis_ág (természetesen az else-vel együtt) elhagyható.

A fenti dolgok elsőre bonyolultnak tűnnek, de próbálgatással könnyű őket megérteni.
A bc egy nagyon ügyes kis program, érdemes bele időt ölni. Ráadásul a fenti ciklusok a legtöbb, valamire való nyelvben megvannak.

Még akarok a bc-ről cikket írni, hiszen még rengeteg bemutatásra váró lehetősége van, de nem tudom, hogy mikor jön a sorozat második része. Addig lehet olvasgatni a manuált.

Jó számolgatást! ;)