2014. december 20., szombat

Két programozási nyelv összehasonlítása

A BASIC (Beginner's All-purpose Symbolic Instruction Code) általános célú programozási nyelvet 1964-ben készítette Kemény János és Thomas Kurtz a Dartmouth College-ben, oktatási céllal. A nyelv alapjait a Fortran programozási nyelv alapján tervezték meg. A nyelv interpretált nyelv, azaz a programot futás közben fordítja a gép saját nyelvére. Elterjedésében nagyban közrejátszottak az 1980-as években elterjedt számítógépek, melyeknél gyakran a számítógéppel egybeépítve adták a BASIC értelmezőt. Ezekben a különböző számítógépeken futó BASIC programok szinte mindig inkompatibilisek voltak egymással: az egyik géptípusra írt programot más számítógéptípusokon nem lehetett futtatni.Nagy lökést jelentett a nyelv elterjedésében a DOS operációs rendszer elterjedése, melynek újabb verzióiba beépítették a Qbasic nevű BASIC változatot. A Qbasic szoros rokonságban állt a Microsoft QuickBasic fejlesztőeszközével, de nem tudott futtatható fájlt készíteni.A 1990-es évek elejére sokan leírták a Basicet, mivel a Basic alapú mikroszámítógépek kora lejárt, PC-n a C/C++ és a Pascal nyelvek vívtak ki vezető szerepet. A Microsoft 1991-ben kiadta a Visual Basicet, ami a legnagyobb megújítása lett a nyelvnek: a QuickBasic strukturált Basic nyelvjárása eseményvezéreltté vált, megjelentek benne objektumorientált vonások, így hatékony és egyszerűen használható Windows fejlesztőeszközzé vált. Tovább segítette a nyelv terjedését két variánsa: Visual Basic for Applications (VBA) az Office programcsomag makrónyelvévé, a Visual Basic Script a Windows operációs rendszer scriptnyelvévé vált.A Visual Basic 2002-ben jelentős átalakításon esett át: megjelent a Visual Basic .NET, ami teljesen objektumorientálttá tette a nyelvet, a .NET keretrendszerhez igazodva. A Visual Basic .NET-ben gyakorlatilag csak a kulcsszavak emlékeztetnek a klasszikus Basicre, a változások olyan mélyrehatóak voltak, hogy még a klasszikus Visual Basickel sem kompatibilis visszafele. Emiatt több kritika érte és éri, sokak szerint csak nevében Basic, a legközelebbi rokonságban a C# nyelvvel van.Noha a Microsoft-féle irányvonal a legelterjedtebb a nyelv fejlesztésében, a Basicnek rengeteg nyelvjárása és értelmezőprogramja van. Könnyű tanulhatósága miatt sokan kezdik a programozást vele. Több speciális célú Basic-változat létezik, például mikrovezérlők programozására vagy játékfejlesztésre.A BASIC nyelvjárások nagy részében nem kell a változókat deklarálni. Az új változókat ebben az esetben a parancsértelmező futásidőben hozza létre a nevük első előfordulásakor. Ez hibalehetőséget jelent annyiban, hogy az elgépelt nevű változók is létrejönnek így. Az idők folyamán azonban több megoldás is létrejött: Az első változatban, a Dartmouth Basic-ben egy, illetve kétjegyű változóneveket használhattunk, az első jegy betű (A-Z), az (opcionális) második számjegy (0-9), így a BASIC összesen 11x26=286 változót tudott kezelni (A-Z, A0-A9,…, Z0-Z9).Az értékadás a LET kulcsszóval történt (például LET x=26), ami több későbbi változatban is benne maradt, bár idővel fölöslegessé válva kikopott.

A változók A Dartmouth Basicben mind lebegőpontos számok voltak, később megjelentek más típusok is. Később a Microsoft által kifejlesztett Quick Basic  programozási nyelv  (QBasic) átmenetet képez az egyszerű BASIC és a magas szintű, strukturált programnyelvek között.  INTERPRETER  típusú nyelv.

A QBasic nem elsősorban adatfeldolgozás céljából kifejlesztett programnyelv.

A forrásnyelvi QBasic program kiterjesztése  .BAS   Ez csak a fejlesztő rendszeréből futtatható.


Lehetséges  .EXE  tárgyprogrammá fordítani, ha rendelkezünk a teljes, fejlesztői környezettel.

1.   A Basic programozási nyelv elemei

1.1.  Program utasítások, parancsok


A programok utasítások sorozatából állnak. Ezen utasítások végrehajtása lehet soros ( lásd pl. a BATCH programok) vagy az utasítások által vezérelt sorrendű (feltételek alapján "elugrik" egy adott program részlethez).


A program utasításai, a PARANCS -ok általában angol nyelven értelmezhető rövid szavak, amelyeket a parancs körülményeit meghatározó PARAMÉTER -ek követnek. A Parancsokban továbbá különböző írásjelek is találhatók, amelyek a parancs szakaszolását, sorrendiségét szabályozzák.



A parancs általános szerkezete:




PARANCS  [ paraméter 1  . . .  |  paraméter N ]



A parancsok szintaktikai elemei:



PARANCS       - parancs szó (szavak), utasítás - a program írása közben ha helyesen adtuk meg és a

                           programsor egyéb eleme is hibátlan, akkor a fordító program automatikusan átváltja

                           NAGY betűre



paraméter / ek / - a parancs paraméterei, bármilyen program elem lehet (azonosító, adat, jel, változó, stb.)



[    ]                  -  a szögletes zárójelen belüli parancs elemek nem kötelezőek, csak megadhatók;



  |                      -  függőleges vonal:  a felsorolt parancs elemek közül egy elem kötelező, de csak az egyik                          szerepelhet,



Példák parancsokra: ( ismeretükre szükség lesz !)



Paraméter nélküli parancsok:



CLS                - a képernyő tartalmát törli, utána a kurzor a bal felső sarokban áll

REM               - ezzel az utasítással kezdődő program sor nem hajtódik végre a futás során

PRINT            - egy üres sort kiíró, (másképp egy sort lefelé léptető) utasítás

RANDOMIZE TIMER   - ha szükséges, az véletlen szám generáló utasítást (RND) előzi meg

END               - a programot záró utasítás



Paraméteres parancsok:



PRINT paraméter1, paraméter2, …   - a paraméter tetszőleges darab szám illetve szöveg lehet

SLEEP mp          - az 'mp'  paraméterben megadott másodpercig felfüggeszti a program futását

BEEP mp, Hz    -  'mp' másodpercig, 'Hz'  hangmagasságú hangot generál a hangszórón

TAB (n)          - 'n' darab helyközzel jobbra lépteti a kurzort illetve a kiíratás helyét n = 1 - 255

SPC (n)           - 'n' darab helyköz karaktert (Spc) ír ki  n = 0 - 32767





1.2.  A programban használt adatok megjelenési formái




1.21. Változók





A változók, a memóriában tárolt  névvel és típus azonosítóval  rendelkező adatok, amelyeknek tartalma a program futása során veszi fel konkrét értékét, (gyakran többször is változik az értéke).



A változó konkrét tartalma a Qbasic -ben  numerikus  érték  vagy  karakter sorozat  lehet.



A változók a program futása során, az  értékadó utasítások,  vagy  beviteli,  INPUT utasítások  által kapják meg, illetve változtatják meg értéküket.



A QBasic  a változó nevében nem engedélyez ékezetes betűket,  csak az angol ABC betűit.



(Az értékadó és  INPUT utasítással később részletesen foglalkozunk.)



*  Megjegyzés:  a változó neveket meg lehet adni csupa NAGY BETŰVEL  és  vEGyesEn is de a program                 szerkesztése közben ez erősen zavaró lehet.  Ha egy változó többször is szerepel a

                        programban (értéket kap majd később ki is íratjuk) akkor a fordító program úgyis azonos

                        (csupa NAGY vagy csupa kis betű) formára konvertálja.



pl.  Szam = 1 :  PRINT Szam            - a fordító elfogadja



      AdAt = 23 :  k = Szam +  adat    - a fordító előbb átalakítja az értékadást is :  adat = 23 –ra

                                                              és ezután futtatja a programot





pl.  A következő program részlet változóinak  ( a ,  N,  nev$ )  tartalma és változásai:



            a = 6                              - az  a  nevű változó tartalma, most  6

            N =  a * a                       - az  N  nevű változó tartalma, most   36

            nev$ =  "Lajos"              - a nev$  nevű változó tartalma, most   Lajos

            a = 33                            - az  a  nevű változó tartalma ettől az utasítástól a program számára   33

            PRINT  a,  N,  nev$      - A kiírás:  33     36    Lajos    lesz, vagyis a változók aktuális értékei

            N = N / 2                       - A korábban  36  értékű  N új értéke  18 lesz  ettől a program sortól                                                           kezdődően.  ( rekurzív értékadás,  lásd később )





A változók típusai:  ( a QBasic nyelvben ! )





INTEGER :    EGÉSZ SZÁM     2 byte hosszon tárolt,   a tizedest kerekíti és úgy számol vele !!!

                        - 32768   és   + 32767  számtartományba esik          ( -216  és  216-1 )

                        Jelölése:    %             pl.  a%,  D%,  szam% 



pl.  a% = 154,   b% = -67,     DE !  c% = 43.2   kiírva:  43  és     D = c% * 1     PRINT D  ¬¬ 43

                                                    x% = 43.7   kiírva:  44  és     D = c% * 1     PRINT D  ¬¬ 44

          



LONG :       EGÉSZ SZÁM       4 byte hosszon tárolt,     a tizedest kerekíti  és úgy számol vele !!!

                    - 2147483648 és  + 2147483647 )  számtartományba  esik   ( -232  és  232-1 )

                    Jelölése:     &                  pl.   b&,  X&,   valtozo&

          

pl.   x& = 2 733 300  vagyis  32767 –nél nagyobb egész szám





SINGLE :       EGYSZERES  PONTOSSÁGÚ      4 byte hosszon tárolt,  tizedes értéket  is tartalmazó,                                                                                       7 számjegy hosszú szám

                      Jelölése:    !        pl.   c!,   H!,    adat!

          

A számtartomány igen kicsi és igen nagy , pozitív és negatív számokra terjed ki, pontosan nem mondható meg, hogy ez mekkora.  Azokat a számokat, amelyeket nem tud már 7 számjegyen pontosan ábrázolni,

(a  9 999 999 –nél nagyobb, a  .000 000 1-nél illetve  -9 999 999  és -.000 000 1 –nél  kisebb számokat),   a szám normál alakjában fogja kiírni.

( 9 999 999 +1 kiírása:  1E+07  azaz 1 * 107   vagy  -.000000032  kiírása:  -3.2E-8  azaz  -3,2 * 10-8  )

pl. d! = 1234.567;   f ! = 1.234567;  g! =  1.234567E+12,                                    





            Ne csodálkozz ! 

x! = 9999999

y! = 5

v! = 10

z! = x! + y!     - kiírása:  1E+07                     a szám pontos értéke viszont:  10 000 004     csak a 7 értékes

            jegy kiíratási korlát miatt a legkisebb helyiértékű  4 –est nem tudja kiírni, de ha kell számol vele

w! = x! + v!          - kiírása:  1.000001E+07    a szám pontos értéke:  10 000 010  amelyből a

7 számjegy kiírható, tehát megjeleníti a pontos értéket

DOUBLE :     KÉTSZERES PONTOSSÁGÚ   8 byte hosszon tárolt, tizedes értéket  is tartalmazó,                                                                              15 számjegy hosszú szám

                        Jelölése:   #     pl.  d#;   F#;   szam#



A számtartományról itt sincs sok értelme beszélni, jóval nagyobb illetve kisebb lehet, mint a  Single típusnál.  A Single típusnál szereplő megállapítások ennél is érvényesek, az eltérés annyi, hogy a 15 darab számjegy dupla pontosságot eredményez a számítások során és ennyi számjegyet tud kiíratni.



 pl.  k# = 234567.89012345;  maxi# = 1.23456789012345E+300



Fontos !    A numerikus változók típusát nem kötelező jelölni  (szintaktikailag nem hibás), viszont ha

                   nem deklaráljuk (írjuk elő) a szám típusát, az alapértelmezésben  SINGLE típusú lesz.





STRING :       KARAKTER LÁNC      maximum   32768   karaktert tartalmazhat egy változó

                        Jelölése:  $    pl.  s$;  V$;  masik$



Karakter alatt az összes betűt, számot és egyéb, megjeleníthető ASCII karaktert értjük.  Az " (idézőjel) karakter megjelenítését kerüljük, mert az külön "trükközést" igényel, mivel az "  " pár egy vezérlő karakter a programban. A String típusú változó értékadása során a jobb oldali karakter sorozatot kötelező idézőjelek közé tenni.



pl.   k$ = "név" ,    Kiiras$ =   "ADATBÁZIS" ,      v1$ = "Első változó"







A QBasic –ben nem önálló adattípusok:  (más programozási nyelvben azonban léteznek)





Dátum:  a QBasic –ben csak lekérdezni lehet a rendszerdátumot, illetve egy STRING típusú változóban

              szabályos dátum  formátumú adat adható meg, amely az új rendszer dátum lesz !



Dátum lekérdezés parancsa:  PRINT  DATE$         eredményül   05-23-2001   formátumot kapjuk



Új dátum megadása:   DATE$ = „hh-nn-éééé”





Figyelem ! Megadható „hh-nn-éé”  formában is de ekkor az  évszázad 19éé lesz.

                 A  –  (kötőjel) jel helyett használható a  /  jel is.





Ha dátum formájú változót akarunk használni a QBasic programban, akkor inkább egy STRING értékadással kell azt definiálni.







Logikai érték:  ( tartalma csak  IGAZ  vagy  HAMIS lehet )





A logikai műveletek léteznek a Qbasic –ben és ott értelmezettek a logikai értéket ( -1 és 0 ) képviselő változók, de külön "logikai típusú" változót a Qbasic nem ismer.



 Célszerű egy INTEGER vagy esetleg egy  STRING típusú változóként definiálni, amelybe a program csak kétféle értéket vagy karaktert enged beírni. Erre rákérdezve lehet majd a logikai (kétértékű) állapot tartalmát megismerni.

Jegyezzük jól meg, hogy a QBasic –ben az  IGAZ :  -1 a  HAMIS :  0 számjegyként  jelenik meg.







1.22. Állandók  / konstans / :





Olyan  numerikus vagy karakteres érték, amelynek nincs név azonosítója, hanem egyszerűen csak egy

numerikus vagy szöveges ADAT.



Az értékadás jobb oldalán szerepelhet csak, mint a változó pillanatnyi értéke, vagy mint egy számítás tényezője (hozzáadandó, szorozni kell vele, stb.) illetve mint egy felirat (kiírandó szöveg a képernyőn).



Szerepelhet még feltétel vizsgálatokban mint amihez hasonlítani kell egy változó értékét, ekkor tetszőleges, hogy melyik oldalon áll.



Fontos, hogy beírásakor az érték megfeleljen a numerikus illetve karakteres típusoknak.





pl.        k = 15   b$ = "Floppy"                                   - a  15  és a  "Floppy"   konstansok

            kkerulet = 2 * R * 3.14                                  - a 2  és a  3.14  konstansok

            AB$ = c$ + "méter"                           - a  "méter"  konstans

            IF  x <  8 THEN  PRINT "Kisebb"   - a  8  és  a "Kisebb"  konstansok





A  QBasic –ben definiálhatunk a teljes programra érvényes konstans értéket, amelyet nem kell mindig beírni, hanem a nevével hivatkozhatunk rá. Az előnye az, hogy újból nem kaphat az adott nevű és típusú változó új értéket: A fordítóprogram figyelmeztet az újbóli értékadásra és nem lehet végrehajtani..



pl.  Sokszor kell a Pi  6 tizedes pontosságú értékét   (3,141593 )  használnunk a számítások során.

            Ebben az esetben a program elején egy utasítással konstansként definiáljuk és később már csak a           nevét kell beírni a megfelelő helyre egy képletben.



            CONST  pi = 3.141593

            . . .

            kterulet =  R ^ 2 * pi

            kkerulet =  2 * R * pi

          

            pi = 3.14                                 - a fordítóprogram ezt az értékadást a CONST után letiltja!

1.23. Kifejezések





A kifejezések, konstansokból, változókból, függvényekből és ezeket összekötő műveleti jelekből álló

(értéket kiszámító aritmetikai képletek vagy string műveletek).



Kifejezések csak az értékadó utasítás bal oldalán állhatnak. Feltétel vizsgálatban is szerepelhetnek kifejezések, ekkor nincs jelentősége, hogy jobb vagy bal oldalon állnak-e.





pl.        X = ( a + b ) * 2 - sin(x) / d ^ 5           - az  egyenlőségjeltől jobbra egy kifejezés van

            A$ =  X$ + "füle"                              - ha X$ = "kutya", az A$ értéke "kutyafüle" lesz





Műveleti jelek :   (  )  [ zárójel ];    +  [ összeadás ];   -  [ kivonás ]; 

                           *   [ szorzás ];    /  [ osztás ];         \  [ egész osztás ];      ^  [ hatványozás ]





A műveletek végrehajtásának sorrendje  ( prioritás ):           (a matematikai szabályok szerinti)





1. Zárójeleken belüli művelet(ek)

2. A hatványozás (alap ^ kitevő) egy értéknek számít

3. A szorzás, osztás

4. Az összeadás, kivonás



Több, azonos szintű  (prioritású)  műveletet   balról  jobbra   hajt végre a program !





pl.        i := A * ( B + C ) ;         k :=  ( D – F ) / ( K + I + Z ) ;          f := E ^ 2  - D / Y  *  ( N - K );

                               1.                            1.               2.                              2.                          1.



                          2.                                          3.                                                         3.                       

                                                                                                          

                                                                                                                          4.



Figyelem !  Az Egész-osztás művelete mindig INTEGER (egész) számot eredményez, függetlenül attól, hogy milyen típusú változó kiszámításánál alkalmaztuk. Az osztást egész különös módon

hajtja végre, amit az alkalmazása során figyelembe kell venni.



Ha  két egész számot osztunk el, akkor egyszerűen levágja az esetleges tizedes jegyeket és eredményül a "csonka"  számot kapjuk.



                                               11 \  4  =  2                 ( a pontos eredmény  2,75  lenne )



Ha valamelyik vagy mindkét szám tizedes jegyet is tartalmaz, akkor előbb kerekít egész számmá, majd ezután végzi el az egész osztást a fenti szabály szerint.

          

            11.6 \ 4 = 3                             11.4 \ 4 = 2                             11.6 \ 4.6 = 2

            ( 12 : 4 = 3 )                           ( 11 : 4 = 2,75 )                                  ( 12 : 5  = 2, 4  )



1.24.  Értékadó utasítások





Az értékadó utasítás a program futása során, egy névvel és típussal rendelkező változónak ad egy meghatározott értéket.





Az értékadó utasítás szintaktikája:                VÁLTOZÓNEV [ típus ]  =  konstans | kifejezés





A  BAL oldal –on  egyetlen változó név áll, a  JOBB oldal –on  konstans vagy kifejezés szerepelhet.

Sohasem fordítva !



pl.  h = 10;    a& = X / 2;    szam! = a * ( y - 3 );      b$ = "szöveg" ;       s$ = d$ + "   " + c$ ;



Figyelem !  az  L =  adat1 = adat2   egy logikai értékadás, amikor az L nevű változó értéke attól függően

                 lesz IGAZ (-1) vagy HAMIS (0), hogy az adat1 =  adat2  egyenlőségi reláció fennáll vagy sem.

                 Ebben az esetben tehát az első  = jel az értékadás a második pedig a reláció kifejezése.



Figyelem !  Feltétel vizsgálat (az IF után) is lehet értékadás "formájú" felírás de ez ott minden esetben

                   egyenlőségi relációt jelent.



pl.   IF  h = 10  OR  szam! = a * ( y – 3)    THEN  …     nem értékadást, hanem a jobb és a bal oldali

       egyenlőség igazságtartalmának vizsgálatát  jelenti, amely hatására majd végre kell hajtani valamit.









1.25.  Speciális változó,  a  TÖMB





A  TÖMB,  több, azonos típusú adat közös, szabályozott szerkezetű tárolását teszi lehetővé.



(Részletes ismertetést lásd a "Programozás Elmélet" című tankönyvben.)



Egy tömb minden eleme tehát  AZONOS TÍPUSÚ,  amit megadtunk a tömb definiáló utasításában.

A tömb "üres" eleme numerikus típusnál alapértelmezetten  0,  karakteres típusnál 0 hosszúságú  string.





Példák tömbre:



- az  A ( i )  tömb  adattartalma, ha  i = 4 és a típusa INTEGER     1323

            41

            452

            9435  







- a  NEV$ ( k, l )  tömb tartalma, ha k = 5, l = 2 és a típusa  STRING        Kiss     Lajos

            Nagy   Ödön

            Kovács            Balázs

            Magyar           Ilona

            Horváth          Rózsa





1.26.  TÖMB definiálásának szintaktikája





A tömböket használatuk előtt, mindig definiálni kell, amire azért van szükség, mert a fordító előre helyet foglal számára a memóriában. A dimenzionálással határozzuk meg, hogy hány dimenziós és dimenziónként hány elemű lesz a tömb. A tömb definíciót tehát célszerű a program elején rögtön megtenni.



A QBasic maximum  60 dimenziós tömböt enged meg.



Van még egy abszolút méret határ is, mert az összes elemszám nem lehet több mint  16384  azaz  214 .



A tömb dimenzionálás szintaktikája:

          

            DIM   változónév   [ (  dimenzió méret  |  kezdőérték TO végérték [ , ... ] )   [ AS  típus ] ]





DIM                a tömb definiálás parancsszava

változónév      az a név amivel a programban hivatkozni lehet a tömbre

(  )                   -ben a  Dimenziószám és a Dimenzió méret kerül leírásra

A Dimenziószám mindig annyi, ahány vesszővel elválasztott Dimenzió méret van a zárójelek között.

A Dimenzió méret -et két módon adhatjuk meg:  (  N  ); ( N, M )   vagy   ( 1 TO N ); ( 1 TO N, 1 to M )

AS       parancs,  a tömb típusának megadását vezeti be

típus    csak valamelyik létező adat típus lehet, amelynek nevét kötelező kiírni. Ha nem adjuk meg

            az alapértelmezés itt is  SINGLE



Figyelem !  A dimenziószám és méret megadása a QBasic –ben kellő odafigyelést igényel.



Ha nem adunk meg (mert megtehetjük) Dimenzió adatot (Számot illetve Méretet), vagyis csak egy

DIM xtomb  a dimenzionáló utasítás, akkor  1 dimenziós, 11 dimenzió méretű xtomb nevű single típusú tömböt használhatunk. A következő program részlet tehát működőképes.

(lásd. P_126 _1 prg.)



DIM   XTOMB

FOR i = 0 TO 10

        XTOMB  =  RND  :  PRINT  XTOMB

NEXT



A dimenzió méretet kétféle módon is meg lehet adni, azonban a két megadás eltérő elemszámot eredményez. Ha  YTOMB ( 10 )  a dimenzionáló utasítás, akkor 11 elemű (0 –tól  10 –ig hivatkozható) tömbünk lesz.

Ha  ZTOMB ( 1 TO 10 ) formában dimenzionálunk, akkor pontosan 10 elemű 1-től 10-ig hivatkozású tömböt használhatunk.

Ugyanígy egy  XYTOMB ( 2, 4 )  tömb  3 sort és 5 oszlopot fog tartalmazni.

(lásd. P_126 _2 prg.)







pl.  DIM  s ( 19 )                                     - 1 Dimenziós,  20 elemű,  SINGLE  típusú tömb

      DIM  szam ( 5, 8 )  AS INTEGER              - 2 Dim, 6 sor, 9 oszlop ( 6x9 ) méretű,  INTEGER típ. tömb

      DIM  K$  ( 2, 6, 3 )  AS  STRING              - 3 Dim.  ( 3 x 7 x 3 ) méretű, 63 elemű  karakteres tömb

      DIM adat ( 1 TO 100 ) AS INTEGER  - 1 Dimenziós, pontosan  100 elemű  INTEGER tömb

      DIM nev$ ( 1 TO 12 ) AS STRING            - 1 Dimenziós, pontosan  12  elemű   karakteres tömb

      DIM m (3 TO 5, 1 TO 8, 6 TO 7 ) AS DOUBLE  - 3 D. (3 x 8 x 2) 48 elemű, DOUBLE típusú tömb

a = 5:   b = 10

       DIM  tomb ( 1 TO  a,  1 TO  b )                   - 2 Dim. (5 x 10)  50 elemű, SINGLE típusú tömb







Hivatkozás egy tömb konkrét elemére:  Ha fel akarjuk tölteni a létrehozott (dimenzionált) tömbünket vagy a tömbben tárolt adatokat fel akarjuk használni, minden egyes elemét meg kell tudni

 "címezni". A "címzést" nevezzük a tömb elemére történő hivatkozásnak. A hivatkozás a névvel és utána zárójelben a Dimenzión belül, az elem sorszám megadásával történik.





pl. az előbb dimenzionált tömbök néhány konkrét eleme:



nev$ ( 3 )                    - a   nev$  nevű tömb  3. eleme

m ( 4, 2, 7 )                 - az  m  nevű tömb  2. sor,  2. oszlop,  2. lapon levő  eleme  ! 

K$ ( 1, 3, 3 )               - a  K$  nevű tömb  1. sor,  3. oszlop,  3. lapon levő eleme

szam ( 2, 8 )                - a  szam nevű tömb  2. sor,  8. oszlop eleme







2. Adatkezelés



Adatokkal végzett műveletek  - bevitel, átalakítás, tárolás, adat kiírás - végrehajtására, a programozási nyelvek saját utasításkészlettel rendelkeznek. Ezt nevezzük adatkezelésnek.







2.1.  Egyszerű Input  / Output  utasítások





Input utasítások:  a feldolgozások alapadatainak bevitelére szolgáló parancsok. ( melyik perifériáról,                                hogyan, milyen formában )



Output utasítások: a feldolgozás eredményeinek eltárolására, formázott képernyős megjelenítésére,     nyomtatására szolgálnak.







2.1.1. Adatbevitel billentyűzetről





Az adatbevitel általános szintaktikája:





INPUT [ ; ]  [ "szöveg" , |  ; ]  változónév  [ típus ]





Ennek hatására a program futása megszakad és a billentyűzetről adat bevitelére vár.

Az adatbevitelnél,  egy konkrét érték (szám vagy szöveg) beírása helyett  Enter  leütésre az eltárolt adat,  numerikus esetén 0,  sztring esetén 0 hosszú karakter "sorozat" lesz.

A változó és a beírt adat típusa csak azonos lehet ! Ha nem egyezik a típus, akkor  REDO FROM START  hibaüzenetet kapunk és a program addig vár a jó adatra, amíg meg nem kapja.



          



INPUT            az adatbevitel parancsszava

;           az  INPUT  utáni  pontosvessző  hatására az újabb adatbevitel ugyanabban a sorban lehetséges vagy a következő  PRINT ebben a sorban folytatódik.

" szöveg "   az adatbevitel helyét jelző villogó kurzor előtt szöveget is kiírathatunk a képernyőn. Ha a                 bevitelt távolabb akarjuk a "szöveg ….." -től. akkor annak végét space -ekkel kell feltölteni.

            A "szöveg" –et követő pontosvessző esetén az inputra váró sorban, a villogó kurzor előtt

            egy  ?  is megjelenik,   vessző  esetén  viszont  nem jelenik meg semmi.

változónév    az input során beírt adatot a program ezzel a névvel tárolja el

[ típus ]         mint más esetben itt is, ha nem kap konkrét típust, az input SINGLE típusú lesz





-           1 darab  numerikus adat bevitele:

          

          

            INPUT [ ; ] [ "szöveg"  ; | ,  ]  változónév [ típus ]

          

          

          

                                                                                                               Megjelenés a beviteli képernyőn:

                                                                                                                  a félkövér a képernyőn megjelenő                     Parancs a programban:                                                                  kiírás a dőlt betűk pedig a billentyű      -                                                                                                        zeten beírt adatok

          

          

            pl.        INPUT  a            ?  23.8

                        INPUT "Bevitel:" , ADAT#     Bevitel: ?  34.6

                        INPUT "Mennyi:        " ; n1!      Mennyi:         100

          

          

-           1 darab karaktersorozat (sztring) bevitele:



          

            INPUT  [ ; ] [ "szöveg"  ; | ,  ]  változónév$

          

          

            pl.        INPUT  B$        ? Bodri

                        INPUT  "Neved :           " ; b$              Neved :              Ica

                        INPUT ; nev$    ? Laci Mi a neved ?  ?  Peti

                        INPUT  "Mi a neved ?",  a$    



A  nev$  előtt levő ; miatt a következő input nem a következő üres sorban kerül beírásra, hanem folytatódik ugyanabban a sorban. (Ez nem azonos a következő utasítással)









-           több adat bevitele egy sorban:





                        INPUT [ ; ] [ "szöveg"  ; | ,  ]  változónév [ típus ] [ , további változónevek [ típus ]]





Lényege, hogy több adatot lehet bekérni egyetlen INPUT utasítással. Alkalmazása azonban szigorú szabályokhoz kötött.

A változók lehetnek vegyes típusúak, numerikus és sztring.

A bevitelkor be kell tartani a (típus miatti) sorrendet és vesszővel kell elválasztani az egyes változókat. Minden adatot kötelezően be kell írni. Az adat lehet üres is de a ',' vessző nem hiányozhat ilyenkor sem.

Hiba jelzés:  REDO FROM START





pl.        INPUT "Adatok:   ", a, b%, c$                                                Adatok   :  3.67, 55,  alma

                        A sorrend a beíráskor csakis  single,  integer,  string adat lehet.

          

                        megfelel a beviteli szabálynak még:                   Adatok   :  , ,  alma

                                                                                                   Adatok   :  3.67, ,  alma

                                                                                                   Adatok   :  , 55 ,

                                                                                                   Adatok   : , ,  enter



2.1.2.  Adatkiírás képernyőre





            A  PRINT parancs szó helyett használható a  ?  beírása.

          

          

            A kiíratás általános szintaktikája:

          

          

          

                                   PRINT   [ , ]  [ "szöveg" ; | , ] [ konstans | változónév [ típus ] | kifejezés ]

                                                         [ ; | ,  további konstans | változónév  [ típus ] | kifejezés ]

                                                         [ ; | , ]  <Enter>

          

          

            PRINT                        a képernyőre írás parancsszava

                 ,                   vessző a PRINT után : már az első kiírás is tabulálva lesz   ( !!  2 db ,  2 -szeres TAB )

            "szöveg"          a kiíratott adatok előtt tetszőleges szöveg kiíratható

            konstans          a PRINT után írt konstans változatlanul kiírásra kerül

            változónév      a változó aktuális értéke kerül kiírásra

            kifejezés          a kifejezés által képviselt (a képletből kiszámított) érték kerül kiírásra

                 ;      pontosvessző az adatok közt:  a soron következő PRINT -elt adatot folyamatosan –  (számot  1                                                üres hely kihagyásával,  szöveget  egybeírva) -  írja tovább a megkezdett sorban

          

                 ,      vessző az adatok közt:  a következő PRINT -elt adatot, tabuláltan  írja ki ugyanabban a sorban.

          

                 ;      pontosvessző az utasítás végén :  a következő PRINT utasítás adatainak kiírását ott fogja folytatni,                                    ahol az előző PRINT abbahagyta, mégpedig folyamatosan

          

                 ,      vessző az utasítás végén:  a következő PRINT utasítás adatainak tabulált kiírását ott folytatja,                                      ahol az            előző PRINT abbahagyta

          

            <Enter>   az utasítás végén :  új sorba írja a következő PRINT -et;

          

            Figyelem !  A ", " és " ; " használata tehát a sor végén, sorfolytonos kiíratást jelent (a programban  bárhol

                        elhelyezkedő)  következő PRINT utasítással.

          

          

          

            Megjegyzés: a kiírató tabulálás 14 karakter széles, nem változtatható.

        (Állítani csak a Szerkesztő képernyő TAB szélességét lehet ! )

          

          

Üres sor kiírása :  (soremelés)               PRINT 

          

          

            pl.        PRINT : PRINT : PRINT              - eredménye:  3 üres sor után folytatódik majd a kiíratás

          

            Az elválasztó  " : " ( kettőspont ) azt eredményezi, mintha új programsort írnánk.

            Adatok kiírása :

          

-           szám konstans (ok)  kiíratása:

          

            A  PRINT parancs után szereplő szám kiíratása változatlan tartalommal és formában.

          

          

                            PRINT  [ , ]  [ "szöveg" ; | , ]  szám konstans      

                                                                          [ ; | , ] [ további szám konstansok ] [ ; | , ] <Enter>

          

          

            pl.        PRINT  145.3,  35                              - eredménye:    145.3            35

                        PRINT  34;  288.47                           - eredménye:     34  288.47

                        PRINT  65 :  PRINT  82.5                             - eredménye:     65

                                                                                                           82.5  

                        PRINT  52 ;

                        PRINT  89.234                                              - eredménye:  52  89.234

          

          

          

-           szöveg konstans ( ok ) kiíratása:

          

            A  PRINT parancs után szereplő karaktersorozat(ok) kiíratása változatlan tartalommal és formában.

          

          

                           PRINT  [ , ]  [ "szöveg" ; | , ]  "szöveg konstans"

                                                                          [  + | ; | , ] [ "további szöveg konstansok" ]   [ ; | , ] <Enter>

                                                   

          

            Csak  sztring kiíratáskor,  a " ; " és  a " + " jel azonos, folyamatos kiíratást eredményez.  A " +  " jelet  úgy is értelmezhetjük, hogy a sztringeket össze is lehet adni.

          

          

            pl.        PRINT  "Pisti"                       - eredménye:    Pisti

                        PRINT  "Macska" ; "farok"       - eredménye:    Macskafarok

                        PRINT  "Macska" + "farok"      - eredménye:    Macskafarok

                        PRINT  "Kutya", "füle"         - eredménye:    Kutya       füle

                        PRINT  "Buda" ;

                        PRINT  "pest"                                    - eredménye:    Budapest

          

          

          

-           változó kiíratása: 

          

            A  PRINT parancs után szereplő változó(k) aktuális értékének kiíratása.

          

          

                         PRINT  [ , ]  [ "szöveg" ; | , ]  változónév

                                                                        [ ; | , ] [ további változónevek ] [ ; | , ] <Enter>

          

          

            pl.        a = 10:  b = 2:  x$ = "A oldal:" :  y$ = "B oldal:"                       ( ezek értékadó utasítások ! )

          

                        PRINT  x$, a,

                        PRINT  y$, b                                     eredménye:     A oldal:        10               B oldal:        2

-           kifejezés kiíratása: 

          

            A kifejezésben meghatározott matematikai művelet eredményét írja ki.

          

          

                        PRINT  [ , ]  [ "szöveg" ; | , ]   kifejezés

                                                                       [ ; | , ] [ további  kifejezések ] [ ; | , ] <Enter>

          

            pl.        a = 10:  b = 2   

          

                        PRINT ”Terület =”;  a * b,                            ( Figyelem ! A sor végén vessző van. )

                        PRINT "Kerület =" ;  2 * (a + b)

          

                        eredménye:          Terület = 20                            Kerület = 24

          

          

          

-           vegyes kiíratás:



A fenti négy adat fajta természetesen vegyesen és tetszőleges sorrendben is kiíratható egyetlen  PRINT  utasítással.





          





2.1.3.  Adat kiírás nyomtatóra





A  PRINT utasítással azonos szintaktikájú  parancs.    ( lásd fent )





Parancsszava:                                       LPRINT  [ paraméterek ]





2.2.    Különleges  Input  / Output utasítások





2.2.1.  Karakteres inputok





                        - egy karakter beolvasása billentyűzetről:

          

          

            változónév$ = INKEY$

          

          

            Ilyenkor a bevitt karakter nem jelenik meg a képernyőn.  A megfelelő karakter leütésére vár a program,     ha megkapta továbbfut.

          

          

            pl.        várakozás a program folytatására, bármilyen billentyű leütése után a program továbbfut

                                 

                                   var:  a$ = INKEY$  :  IF a$ = ” ” GOTO  var

                          

            várakozás a program folytatására, majd a bevitt karakter alapján ugrás a program egy

                        meghatározott pontjára



                                   var:  a$ = INKEY$  :  IF a$ = ” ” GOTO  var

                                IF a$ = " I "  GOTO  címke1









                        - megadott számú karakter  (sztring) bevitele billentyűzetről:

          

          

            Ebben az esetben nem jelenik meg a képernyőn sem az  INPUT –nál megszokott   " ? " sem a beírt karaktersorozat.

            Annyi történik csak, hogy a zárójelben megadott hosszúságú karakterlánc (sztring) beírása után a program folytatódik a következő utasítással. Amíg nem töltjük ki a teljes hosszat, (akár szóköz karakterrel vagy <Enter> leütésekkel), addig várakozik a program.

            Az utasítás eredményeképpen a karakteres változó aktuális tartalma a bevitt karaktersorozat lesz.

            Akkor használjuk, ha a bevitt karakterek számát valami miatt korlátozni kell.  ( pl. max. hosszú 10 lehet )

          

          

            változónév$ = INPUT$  ( hossz )

          

          

            pl.   adat$ = INPUT$ ( 15 )        - maximum 15 karakter hosszú sztring beolvasása billentyűzetről

          

          



2.2.2.  Formázott adatbevitel és kiírás a képernyőre

          

          

-           pozícionált  I  / O  a képernyőn:          (az INPUT vagy OUTPUT utasításra van hatással)





 LOCATE  [ sor ]  , oszlop





[ sor ]       A kiíratást sorának sorszáma.  Értéke  1 és  25 közötti pozitív szám lehet. Megadása nem

                kötelező. Ha elhagyjuk, akkor a kiíratás a következő sorban a megadott oszloptól történik.

                Ezt nevezzük Relatív pozícionálásnak.

                Ha mindkét paramétert ( sor, oszlop ) megadjuk, akkor  Abszolút pozícionálásról beszélünk.

                A 25 -ös sor érték megadása azt eredményezi, hogy a következő kiírató utasítás hatására a

                 képernyő  1. sorába írt adatok "felfelé kicsúsznak" a képernyőről.

                          

    ,           A két paramétert elválasztó vessző, beírása akkor is kötelező, ha csak az oszlopot adjuk meg





oszlop      A kiíratás kezdetének oszlop száma (amelyik oszlopban az első karakter kiírásra kerül )

                Értéke  1  és  80  közötti pozitív szám lehet. Megadása kötelező.

                Megadásakor mindig figyelembe kell venni, hogy az oszlop paraméter értéke plusz a kiírandó                              adatok hossza együtt maximum 80 karakter lehet, mert ellenkező esetben a teljes kiíratás átcsú-                           szik a következő sor elejére.





pl.        LOCATE  12,  20         - a 12. sor, 20. oszlopától ír                                ( abszolút pozíció megadás )

            LOCATE  , 15              - a következő (azaz a 13. sor),  15. oszlopától ír  (relatív pozíció megadás)



LOCATE  5,  71 :  PRINT "1234567890"    (még éppen elfér az 5. sor végén  DE ha 72 –t                                                                                   adunk meg az egész átkerül a 6. sor elejére)





Ahhoz, hogy az adatbevitel vagy kiírás a képernyő egy meghatározott sor - oszlop pozícióján kezdődjön,  az  INPUT  illetve a  PRINT előtt ki kell adni a LOCATE [x] , y  parancsot.  A következő  I / O utasításra viszont már nincs hatással, pozícionálás nélkül (vagyis újabb LOCATE [x] , y  parancs nélkül) az a következő sor 1. pozíciójától íródik ki.

Ha pozícionálni akarjuk a következő  I / O utasítást is, újra ki kell adni a parancsot.  ( ami abszolút vagy relatív pozícionálás is lehet )





            - színek alkalmazása:   ( karakteres üzemmódban )





Beállítható a betű és a mögötte lévő háttér színe.  16 szín használható, 0 - 15 kódokkal. ( próbáld ki )

Karakter villogás:  karakterszín + 16

A szín beállításnak, mindig a PRINT előtt kell lennie és mindaddig érvényes, amíg meg nem változtatjuk.

Ha színeket használunk, a program végén célszerű visszaállítani az alapértelmezés szerinti fekete háttér, fehér betű kiíratást, azaz  COLOR  7, 0  parancsot kell kiadni.





            COLOR   karakterszín  [ ,  háttérszín ]







pl.        COLOR 15 , 4 :  PRINT "szöveg"      - eredmény:  intenzív fehér színű betűk, piros alapon



            COLOR 4  :  PRINT "szöveg"                         - eredmény:  piros betűk az alapszínű háttéren





A  16  alapszín:





Kód     Szín – magyar Szín - angol

0          fekete  black

1          kék      blue

2          zöld     green

3          cián     cyan

4          piros    red

5          bíborvörös       magenta

6          barna   brown

7          fehér    white

8          szürke  gray

9          világos kék      light blue

10        világos zöld    light green

11        világos cián     light cyan

12        világos piros    light red

13        világos bíbor   light magenta

14        sárga    yellow

15        intenzív fehér  high intensity white







Megjegyzés:  a COLOR alkalmazása a grafikus képernyőn, összefügg a képernyő felbontását meghatározó               SCREEN utasítás tartalmával.  (Lásd a grafikus képernyő kezelést.)

            - formázott kiíratás képernyőre:       



          

PRINT  [ , ]  [ "szöveg" ; | , ] USING  forma-karakterek ;  konstans | változónév | kifejezés

                                                          [  ; további konstansok | változónevek | kifejezések ] [ ; ] Enter

                      

          

Figyelem !   A forma-karakterek utáni, a további adat felsorolást elválasztó és a záró pontosvessző

                   kötelező, nem lehet vessző !

                   Az utasítással kötelező legalább egy adatot kiíratni !



            forma-karakterek:   a kiírás formátumát meghatározó karakterek



                        #                      : számjegyek helyének meghatározása

                        .                       : tizedespont helyének meghatározása

                        +                     : az előjel kiíratása

                        !                      : a string első karakterének kiírása

                        \  \                    : a string első  2 + n  darab karakterének megjelenítése

                                                           a \ \  jelek között n darab helyköz karakter (space) helyezhető el



További formázó karaktereket lásd a  QBasic  HELP -ben.





pl.        szam = -123.45 :  ertek = 1234.567  : betu$ = "ABCDEFG" :  a = -12



            PRINT USING " + ###.## " ; szam              - eredmény:  - 123.45

            PRINT USING "    ###.## " ; ertek              - ( hiba jelzés)  % 1234.57

            PRINT USING " ####.###### " ; ertek                   - eredmény:  1234.56798

            PRINT USING " ! " ; betu$                          - eredmény:  A

            PRINT USING " \   \ " ; betu$                                  - eredmény:  ABCD

            PRINT "A:" ,  USING "+##.#" ; a                - eredmény:  A:              -12





Ha több az értékes tizedes jegyek száma a megadottnál, akkor kerekít, ha viszont kevesebb, akkor kipótolja számokkal. Ha az egészek száma több, azért kiírja de hiba jelzést ad:  %  jelet tesz az elejére.



A formátum megadása után több adatot is ki lehet íratni. Az így kiírt adatok azonos formátumúak lesznek. Az adatok közötti elválasztó karakter csak " ; "  lehet (a fordító automatikusan átváltoztatja a " , " vesszőt)  A megfelelő tagolásról a formátum megadásával kell gondoskodni, mert a " ; " miatt  folyamatos kiíratás történik.



pl.        PRINT USING " ####.## " ;  123.56; 1234; 123.45            - eredménye:  123.451234.00 123.45

            PRINT USING " #######.## " ;  123.56; 1234; 123.45      - eredménye:  123.45   1234.00    123.45

3.  Adat beolvasás  READ - DATA  utasítás párral





DATA utasításban tároljuk azokat beolvasandó adatokat, amelyeket egy vagy több READ -del majd be akarunk olvastatni.



DATA  adat 1, adat 2, . . . , adat Z

.

.

READ adatnévA, adatnévB, . . . , adatnévM

.

READ adatnévN, adatnévP, . . . , adatnévZ







Ahhoz, hogy a program futása során adatokat tudjunk beolvasni a READ utasítással, a program tetszőleges helyén (sorában) el kell tárolni ezeket az adatokat, a DATA utasítás utáni felsorolással. A  DATA utasítás több adatot is tárolhat, mint amit beolvasunk, ugyanakkor a beolvasandó adatok több DATA utasítással is eltárolhatók. A DATA adatait több READ utasítással is beolvastathatjuk, ugyanakkor több DATA utasítás folyamatos beolvasása is lehetséges egyetlen READ –del.

A beolvasás történhet egy vagy több  READ  utasítással is, de a beolvasás szigorúan sorrendben történik, vagyis egy következő READ onnan folytatja a beolvasást, ahol az előző abbahagyta.

A beolvasás sorrendje azért is fontos, mert az eltárolt majd beolvasott adat csak azonos típusú lehet. Eltárolt adatot kihagyni a beolvasás során úgy lehet, hogy beolvassuk, de nem használjuk fel.



pl.        DATA „Kovács”, 1998, „május”, 17, 180,  „F”, 11, „D”, 6

            READ nev$, ev, honap$,  nap,  kor, magas, nem$

            READ evfolyam$, osztaly$, sorszam

            PRINT sorszam, nev$, evfolyam$, osztaly$ - eredmény:    6    Kovács    11  D

            PRINT ev, honap$,  nap                                - eredmény:    1998  május  17

            PRINT kor, magas, nem$                              - eredmény:    17    180     F



            DATA 1, 2, 3, 4

            DATA 5, 6, 7, 8

            READ  a, b, c  :  PRINT  a, b, c                    - eredmény:     1          2          3

            READ  x, y, z  :  PRINT  x, y, z       - eredmény:     4          5          6

            READ  p, r      :  PRINT  p, r            - eredmény:     7          8







Mód van az adatok újbóli - elölről kezdődő - beolvasására is, ha a READ  után  kiadtunk egy  RESTORE  parancsot.





            DATA  "Első",  "Második"

            READ  a$, b$ :  PRINT  a$, b$                    - eredmény:      Első    Második

            .

            RESTORE

            READ x$, y$ :  PRINT  x$, y$                     - eredmény:     Első    Második





4.  Logikai érték jellemzők





A logikai érték:  False  (hamis)  és  True  (igaz)  lehet.



            A  QBasic logikai értékei:     0  False    illetve     -1  True 





Logikai konstans valójában nem is létezik önállóan a QBasic nyelvben, csak egy   0   vagy   -1 értékű   numerikus érték képviseli a hamis vagy az igaz logikai értéket.

Ez a két numerikus érték alkalmazható logikai  (BOOLE) függvényekben konstansként.



            pl.        M = -1  (igaz)

                        M  AND  -1  OR  0    ( olvasd:   M logikai értéke ÉS  igaz  VAGY  hamis )

          



A logikai változó, olyan (típus jelzés nélküli, tehát gyakorlatilag single típusú) változó,

amelynek az értéke 0 vagy –1.

A valóságban ez  0 vagy -1 értékű szám, amit az is bizonyít, hogy matematikai műveletek is végrehajthatók vele DE ha relációban vagy logikai függvényben használjuk, akkor  igaz vagy hamis logikai értékként funkcionál.



            pl.      A = -1 :   B = 0

                      i = A * 12                            eredménye:  -12      vagyis  az  i értéke  -12



            DE:    C =  A  OR  B                    eredménye:  igaz,  vagyis  a  C értéke  -1  (igaz)

                      D =  0  OR  B  OR  A < 3.5    eredménye:  igaz,  mert  A < 3,5  reláció   igaz



ugyanakkor !    PRINT  A * C                             eredménye:  +1  kiírás lesz, mert (-1 * -1) –et íratunk ki   







BOOLE  függvények:     NOT    - a negációs függvény, amely megfordítja a logikai értéket

                                    AND    - az  ÉS  kapcsolat függvénye

                                    OR      - a  VAGY  kapcsolat függvénye



Léteznek még az  XOR;  EQV;  IMP logikai függvények, amelyeket a QBasic nem alkalmazza.







A logikai függvények feldolgozásának sorrendje:



Először a  NOT függvény hajtódik végre, majd az  OR illetve az  AND, amelyek azonos szinten vannak. Ha mindkettő szerepel egy kifejezésben, akkor a Balról  Jobbra szabály érvényesül itt is, mint például a matematikában a szorzás, osztás esetén. A zárójelezés azonban elsődlegesen meghatározza a végrehajtási sorrendet (mint a matematikában).



Műveleti sorrend tehát:                      1.  a NOT           2.  az   AND      OR 





pl.        A = -1 (igaz);   B = 0 (hamis);  C = -1 (igaz)   



X = A  AND  B ;       Y = A  AND  C ;      Z = A  AND  B  OR  C ;      K = X  OR NOT  B

   X  tehát hamis ;         Y tehát  igaz ;           Z tehát  igaz ;                       K tehát  igaz





Figyelem !  A változó nevek adásakor célszerű betartani azt a szabályt, hogy ha egy változót logikai

                    változóként akarunk használni, akkor NAGY betűvel ,ha pedig single típusú számként,

                    akkor  kis betűvel írjuk.





BOOLE  függvény táblázatok, a  QBasic jelöléssel:





  A   NOT  A                      A  OR   B  = C                                        A  AND  B = C



A          A                 A         B         C                     A         B         C

-1         0                      0          0          0                      0          0          0

0          -1                    0          -1         -1                    0          -1         0

                                   -1         0          -1                    -1         0          0

                                   -1         -1         -1                    -1         -1         -1





A reláció, relációjellel összekapcsolt numerikus vagy string  konstansok és/vagy változók, amelyek értékétől és a reláció jellegétől függően  IGAZ vagy HAMIS logikai értéket képvisel.

Másképpen:  a relációjel két oldalán elhelyezkedő numerikus vagy string értékek viszonya, amely vagy megfelel az alkalmazott relációjelnek vagy nem.



Relációjelek a QBasic programnyelvben:        = ;     > ;    > = ;     <  ;    < = ;    <> 



pl.        a = 10 :  b = -6 :  a$ = "magas" :  b$ = "hosszú"

            3.14 > 10        reláció  értéke:            HAMIS

            a <> b             reláció  értéke:            IGAZ

            b <= 1             reláció  értéke:            IGAZ

            a$ = b$                       reláció  értéke:            HAMIS

            a$ <> b$         reláció értéke: IGAZ



A sztring értékek relációja természetesen a karakterek növekvő sorrendbe rendezett ASCII kód értékeire értelmezett. Egyszerűbb esetekben csak az egyenlőség (azonos) vagy nem-egyenlőség (nem azonos) relációk használatosak.



pl.        x$ = "aa" :  y$ = "ab"             (az  ASCII kódok:  "aa"   097 097;  "ab"   097 098 )

          

            x$ = y$                      reláció éréke:   HAMIS

            x$ < y$                       reláció éréke:   IGAZ

            x$ <> y$         reláció éréke:   IGAZ

            x$ > y$                       reláció értéke: HAMIS        



A logikai kifejezés   RELÁCIÓK  valamint  logikai konstansok  és/vagy  logikai változók,  BOOLE függvények által összekapcsolt sorozata.



pl.        x = 10 :   Y = 0 :   z = -3 :  V = -1

          

            A =  x < 15   OR   z + 5 < -10   AND  V                   A   értéke:  IGAZ

            H = Y  OR  A  AND  NOT  x <= z              H   értéke:  IGAZ











5.  Program elágazások





Ha feltétel(ek) alapján a programnak eltérő feladatot kell végrehajtania, akkor ezt az úgynevezett program elágazás segítségével tehetjük meg.



Megjegyzés:  az elágazások részletes, elméleti tárgyalása a  "Programozási Alapismeretek" tankönyvben                                 lehet tanulmányozni. Itt a QBasic gyakorlatát lehet elsajátítani.



Az egyes programágak kezdőpontjait, CÍMKE jelöli. A címke egy név a végén kettősponttal.                   Az elágazásnál ezekre a címkékre kell hivatkozni, a nevükkel.







5.1.  A címke alkalmazásának szintaktikája:



-  amikor egy utasítás sorban szerepel, mint folytatási pont kijelölés, csak a nevét adjuk meg

            pl.  GOTO  cimke3                - jelentése:  lépjen át a cimke3 címkéjű programsorra



-  annak a programsornak a jelzése, ahol folytatni kell a programot. Ebben az esetben kötelező a " : "

   kiírása



            pl.  cimke3 :  PRINT adat      - jelentése: ez az a sor, ahol folytatni kell a programot



A címke alkothat önmagában egy "üres" program sort, de következhet utána mindjárt a program ág első utasítása is (mint az előző példában).







5.2.  A QBasic -ben alkalmazható elágazás típusok





- egyirányú elágazás: abban az esetben alkalmazzuk, ha a feltétel teljesülésekor végre kell hajtani valamilyen műveletet (vagy művelet sort), egyébként pedig nem, azaz folytatódhat a program a következő utasítással.

Algoritmusa:



            Feltétel vizsgálat:

                 Ha a feltétel teljesül, ugrás  a C1:  címkére, és a program folytatása onnan

                 Ha a feltétel nem teljesül, folytatás a következő utasításon





pl.        C1: címke

                   BE:  adat    billentyűzetről

                   HA  adat  <  0  AKKOR  ugrás  C1  címkére

                   PRINT adat



A billentyűzeten beírt adat  nevű változó negatív értéke esetén  ismételt adatbekérés történik, egyébként pedig az adat értékét kiíratjuk.





Nem csak  ugró (GOTO) utasítás lehet a "teljesül" ágon, hanem valamilyen utasítás is, amit végre kell hajtani, majd folytatni a programot.



pl.        BE:  adat    billentyűzetről

            HA  adat  <  0  AKKOR  adat :=  adat * (-1)

            PRINT adat



A billentyűzeten beírt adat  nevű változó negatív értéke esetén, beszorozzuk az adat  -ot  (-1) –gyel és kiíratjuk az értékét.





Vegyük észre ! Minden esetben az adat pozitív előjelű értéke kerül kiírásra, mert ha nem kisebb nullánál,

akkor kikerüli a program a (-1) -gyel való szorzást és folytatja a következő, kiíró utasítással a programot.





- kétirányú elágazás: a vizsgálati feltétel teljesülése illetve nem teljesülése esetén, más-más tevékenységet kell elvégezni, majd folytatni a program futását. A program ágak utolsó utasításainak kell gondoskodni a továbbfolytatásról.

Algoritmusa:



            Feltétel vizsgálat:

                 Ha a feltétel teljesül, ugrás  a C1: címkére, és az ott szereplő program utasítások végrehajtása

                 Ha a feltétel nem teljesül, ugrás  a C2: címkére, és az ott szereplő program utasítások

                        végrehajtása

pl.            ….  a programban elértünk a telefon kérdéshez

            BE: "Van mobilod ?" ,  valasz$

                HA  valasz$ = "VAN"  AKKOR  ugrás a  C1: címkére   HA valasz$ <> "VAN"

                                                                                                    AKKOR ugrás az C2: címkére

            C1: címke

                BE: "Írd be a telefonszámodat:", tsz$

                BE: "Írd be a nevedet is:", nev$

                KI: "Köszönöm"

                Ugrás a C3: címkére

             C2: címke 

                KI: "Az alábbi kereskedőknél szerezhetsz be mobil telefont:"

                KI:  A kereskedők listája.

            C3: címke

                KI: "Kérem a további adataidat !"

                BE: "Lakhelyed:", lh$

                                                           és a program folytatódik tovább  ….





Az algoritmus egy adatfelvételi program részlete, amelyben attól függően, hogy van-e a személynek mobil telefonja vagy nincs, két program ágon kell végighaladnia, majd egy közös ponton továbbfolytatni az adatfelvételt.

A  C1 ágat lezáró C3 címkére ugrató utasítás a C2 címkét követő felesleges utasításokat ugorja át.

A  C2  ág végén ilyen nem kell, mert innen úgyis tovább folytatódik a program.





A nem teljesülő  ágat nevezzük "egyébként" ágnak is, mert az algoritmust így is fel lehet írni:



            Feltétel vizsgálat:

                 Ha a feltétel teljesül, ugrás  a C1: címkére, és az ott szereplő program utasítások végrehajtása

                 Egyébként,  ugrás  a C2: címkére, és az ott szereplő program utasítások végrehajtása



          



Az előző példában szereplő elágazó utasítás eszerint így szól:





BE: "Van mobilod ?" ,  valasz$

               HA  valasz$ = "VAN"  AKKOR  ugrás a  C1: címkére  EGYÉBKÉNT ugrás az C2: címkére











- több, lehetséges elágazási pontra ugrás: különböző feltételek teljesülése esetén más-más feladatot

                             kell elvégezni, illetve ha egyik sem teljesül szintén mást.





A vizsgálatok N számú sorozata zajlik. Plusz szolgáltatása, hogy lekezeli azt a lehetőséget is, amikor egyik feltétel sem teljesül.



Emlékeztetőül az algoritmusa:



HA az  1.  feltététel teljesül, AKKOR  hajtsa végre az utasítás1–t   (és folytatódik a program)

HA a   2.  feltététel teljesül, AKKOR  hajtsa végre az utasítás2–t    (és folytatódik a program)

 .

 .

HA az N.  feltététel teljesül, AKKOR  hajtsa végre az utasításN–t   (és folytatódik a program)

HA egyik feltététel sem teljesül, hajtsa végre az EGYÉBKÉNT ág utasítás –át    (és folytatódik a program)



Az utasítás1,  utasítás2, … , utasításN  értelmezhető egy-egy ugrási címnek is, ahova a program átugrik és az ott szereplő utasításokat hajtja végre.





HA az  1.  feltététel teljesül, AKKOR  ugrás a C1: címkére

HA a   2.  feltététel teljesül, AKKOR  ugrás a C1: címkére .

 .

HA az N.  feltététel teljesül, AKKOR  ugrás a C1: címkére

HA egyik feltététel sem teljesül, az EGYÉBKÉNT ágon ugrás a CN: címkére





5.3.  A QBasic program elágaztató utasításai





- közvetlen ugrás címkére:

          

            Az ugrás nincs feltételhez kötve, a program a címkenévvel jelzett soron folytatódik



GOTO  címkenév



pl.        GOTO  K1                             - a program a  K1: címkéjű soron folytatódik





- egyszeres IF elágazás:



            IF  logikai kifejezés  THEN  utasítás(ok)





A logikai kifejezés  IGAZ  értéke esetén végrehajtja a THEN után szereplő utasítás(oka)t,

                              HAMIS  értéke esetén átlépi az(oka)t és a soron következő utasítást hajtja végre



pl.        IF  a < b  THEN   c = b – a :  PRINT c

            c = a - b

            PRINT  c



- kettős  IF  elágazás:  I / H feltételtől függő végrehajtás





IF  logikai kifejezés  THEN utasítás(ok)  ELSE  utasítás(ok)





A logikai kifejezés IGAZ  értéke esetén végrehajtja a THEN után szereplő utasítás(oka)t, majd a                                               soron következő utasítást hajtja

                             HAMIS  értéke esetén végrehajtja az ELSE után szereplő utasítás(oka)t, majd a                                             soron következő utasítást hajtja







pl.        IF  a < b  THEN  c = b – a :  d = c ^ 2   ELSE  c = a – b : d = SQR ( c )

            PRINT  c, d



            IF  a < b  THEN  PRINT  a  ELSE  GOTO  cimke4







Megjegyzés:  A program elágazás mint látható, nem mindig ugró utasítással valósul meg.

A  THEN utasítást közvetlenül követhetik a végrehajtandó utasítások is.

Az  IF utasításban alapértelmezés az, hogy az  ELSE ág automatikusan, a következő program  soron  folytatja a végrehajtást.













- többszörös  IF  elágazás:   láncolt feltételek alapján történő elágazás





Ebben az esetben több sorosan  (egymás után) vizsgálandó logikai kifejezés  van, és mindegyik feltételhez tartozik egy-egy végrehajtandó utasítás.  Csak az az egyetlen utasítás kerül végrehajtásra, amely a vizsgálat sorrendjében először  IGAZ –nak bizonyuló feltételhez kapcsolódik. A hátralévő feltételek vizsgálata nélkül folytatódik a program (még akkor is, ha a sorban következő feltételek valamelyike szintén igaz lenne).



Fontos jellemzője ennek az összetett feltétel rendszernek, hogy ha egyik feltételt sem teljesíti a vizsgált adat, akkor lennie kell egy EGYÉBKÉNT ágnak is, amelynek utasítását végre kell hajtani.





            IF   logikai kifejezés1   THEN 

                                   utasítás1

                        ELSEIF  logikai kifejezés2   THEN 

                                   utasítás2

                        [ ELSEIF logikai  kifejezés3   THEN

                                    utasítás3 ]

                        .

                        .

                        [ ELSEIF  logikai  kifejezésN   THEN 

                                   utasításN ]

                        ELSE  utasításH

            END IF





Fontos !   Szintaktikai szabály, hogy a  THEN  utáni utasítások mindig új program sorban szerepelnek !

                Az  ELSE  -t  követő utasítás folyamatosan írható.







pl.        INPUT "max 100 lehet: ", a

            IF a <= 20 THEN

                        PRINT a, "Húsznál kisebb"

                   ELSEIF a < 40 THEN

                        PRINT a, "Harminckilenc és huszonegy közé esik"

                   ELSEIF a >= 40 AND a <= 80 THEN

                         PRINT a, "Negyven és nyolcvan közé esik"

                   ELSE  PRINT a, "Nyolcvanegynél nagyobb"

            END IF





-  konkrét értéktől függő elágazás: egy változó előre ismert értékeitől függő elágazás (a CASE  utasítás)





            SELECT  CASE  vizsgálandó változó neve



                        CASE  hasonlító kifejezés 1.

                                   végrehajtandó utasítás(ok)

                        CASE  hasonlító kifejezés 2.

                                   végrehajtandó utasítás(ok)

                            .                       .

                        CASE  hasonlító kifejezés N.          

                                   végrehajtandó utasítás(ok)



                        CASE  ELSE           

                                   különben végrehajtandó utasítás(ok)



            END  SELECT





            A hasonlító kifejezés lehet: 



                        konstans  vagy   matematikai képlet                             pl.  3;  x/y

                        IS  relációjel   konstans  vagy   matematikai képlet              pl.   IS  < 2;   IS  >=  a * b

                        értéktől    TO   értékig                                                           pl.   5  TO  7



pl. a félévi számítástechnikai osztályzat véleményezése



Előbb  IF  -  THEN  szerkezettel:        ( egyszerű  IF  - THEN  sorozat )



            INPUT  ”Hányasod volt Számtekből ? ”,  jegy

            IF  jegy  <  1  THEN  PRINT  ”Rossz input”

            IF  jegy  =  1  THEN  PRINT  ”Megbuktál ! ?”

            IF  jegy  >=  2  AND  jegy  <=  4  THEN  PRINT  ”Számtekből neked már minden jegy jó ?”

            IF  jegy  =  5  THEN  PRINT  ”Te kis zseni !”

            IF  jegy  >  5  THEN  PRINT  ”Érdekes osztályzat !”





Majd  CASE  utasítással:



            INPUT  ”Hányasod volt Számtekből ? ”,  jegy

          

            SELECT  CASE  jegy

                        CASE  IS  <  1

                                   PRINT  ”Rossz input”

                        CASE  1

                                   PRINT  ”Megbuktál ! ?”

                        CASE  2  TO  4

                                   PRINT  ”Számtekből neked már minden jegy jó ?”

                        CASE  5

                                   PRINT  ”Te kis zseni !”

                        CASE  ELSE

                                   PRINT  ”Érdekes osztályzat !”

            END  SELECT

6.  Ciklusok





6.1.  A QBasicben alkalmazható ciklusok





Azonos feladat vagy feladat sor többszöri végrehajtása céljából alkalmazott program elem.

Az, hogy hányszor kell végrehajtani a feladatot függhet feltételtől vagy előre megadott számtól.

A feltétel kielégítésének vizsgálata lehetséges a ciklus elején és végén.

A ciklusokban is a címkéket használjuk az ismétlés kezdőpontjának meghatározására.



A ciklus felépítése:  - előkészítés

                              - feltétel vizsgálat

                              - ciklusmag





-  elöl tesztelő ciklus: a feltétel vizsgálat a ciklusba belépéskor történik és csak akkor hajtódik végre a                                      feladat, ha a feltétel még nincs kielégítve.

A ciklus mag  esetleg egyszer sem hajtódik végre !







                                            



























Algoritmusa:



       Előkészítő (általában értékadó) utasítások

C1: Feltétel vizsgálat

                        Ha  IGAZ, a ciklusmag utasításai végrehajtódnak és visszaugrik a C1:  -re

                        Ha  HAMIS, ugrás a ciklus utáni első program sorra





pl.                  a = 1

            ujra:  INPUT b

                     IF  b <> 0 THEN    a = a * b :  PRINT a, b :  GOTO  ujra     - a ciklusmag

                     PRINT a, ”Vége”



Amíg az input értéke nem nulla (FALS), az a értékét újra számoljuk és ki is íratjuk a két számot. Amint a billentyűzeten nullát írunk be (TRUE) a folyamat leáll és kiíratjuk az a értékét és a  Vége feliratot.



-  hátul tesztelő ciklus: a feltétel vizsgálat a ciklus végén történik.



A ciklusmag itt is csak akkor hajtódik végre ha feltétel nem teljesül.  Mire a vizsgálat megtörténik azonban már egyszer futott a ciklusmag, tehát:



A ciklusmag legalább egyszer végrehajtódik !



































Algoritmusa: 



       Előkészítő (általában értékadó) utasítások

C1: A ciklus mag utasításainak végrehajtása

            Feltétel vizsgálat

                        Ha IGAZ, visszaugrik a C1:  -re

                        Ha HAMIS, ugrás a ciklus utáni első program sorra





pl.                 a = 0

            ujra:  INPUT b

                     a = a + b:  PRINT ”Eredmény:”, a                               - a ciklusmag          

            IF  a < 1000 THEN  GOTO ujra

                     PRINT a, ”Vége”





- meghatározott számszor végrehajtott ciklus:  konstans vagy számított érték lehet





A végrehajtás száma lehet előre konstansként megadott, vagy maga a ciklus számítja ki. Lehet elöl- vagy hátul tesztelő is, attól függően, hogy a végrehajtás számának ellenőrzése a ciklus elején vagy végén történik.



pl.        Számított, hátul tesztelő ciklus:                                k = 0  :  s = 0

                                                                       ujra:     s = s + k

                                                                                   k = k + 1

                                                                                   IF  k < 10  THEN  GOTO  ujra

                                                                                   PRINT ”Eredmény:”, s, k





6.2.  A QBasic programnyelv által definiált ciklusok:





Az eddig megismert ciklusokat a programozó szervezte.

A programnyelvek rendelkeznek ciklus szervező utasításokkal, amelyeket tulajdonképpen csak paraméterezni kell.





- a  FOR  -  NEXT  ciklus: 



            FOR  kezdő érték  TO  végső érték [ STEP  lépésköz ]

                . . .  a ciklusmag utasításai  . . .

            NEXT



A FOR – NEXT  ciklus  3 numerikus értéket tartalmaz:   a ciklus KEZDŐ- és   VÉGÉRTÉK –ét valamint

                                                                                   nem kötelezően a  LÉPÉSKÖZ –t             





A Kezdőértéket  a QBasic Értékadó utasítás formájában kéri.         pl.  i =  1



A három numerikus érték nem csak konstans (egy konkrét számérték) lehet, hanem olyan változó is, amely a program futása során már korábban, értéket kapott.  Ezek a  CIKLUS VÁLTOZÓK. Ezen túlmenően a Ciklus változók lehetnek még  Kifejezések is.



Tehát a Ciklus változók de a Ciklus mag  utasításai is igényelhetik az előzetes értékadást, amit használni kell a számítások során.



A Lépésközt nem kötelező megadni. Ilyenkor az alapértelmezése  1, azaz egyesével nő a Kezdő érték.

A számlálásos ciklus bármelyik, vagy mindegyik numerikus eleme lehet tizedes is, sőt negatív érték is.

Azt a változót, amely a ciklus során a Kezdőértéktől, a Lépésközzel módosított értékeket felveszi, a Végértékig,  SZÁMLÁLÓ –nak nevezzük.





Fontos !          Ha a    Kezdőérték  <  Végérték,    akkor a Lépésköz csak  Pozitív  szám lehet.

            Ha a    Kezdőérték  >  Végérték,    akkor a Lépésköz csak  Negatív szám lehet.

            Ha a    Kezdőérték  =  Végérték,    akkor a ciklus egyszer lefut (mert hátultesztelő ciklus)



pl.        FOR i = 1  TO  20



                        PRINT ”Valami:”, i                        

                         .                                 ------ ez a ciklusmag

                         Számítás, kiírás, stb.                       

            NEXT







pl.        FOR k = 100  TO  -100  STEP  - 5



                        PRINT ”Érték:”, k                           

                          .                                ------- ez a ciklusmag

                        További utasítások                           

            NEXT

- a  DO  WHILE  ciklus:





Az „utasítások” mindaddig végrehajtódnak, amíg a feltétel  IGAZ.





            Elöl tesztelő változat:                        DO WHILE  feltétel

                                                                                  utasítások

                                                                       LOOP

pl.        i = 0                                                                                     

            DO  WHILE  i < 10                                                

                        PRINT i                                                                   

                        i = i + 1                                                                    

            LOOP                                                                                 

            REM  Az i  értéke 9 lesz.







            Hátul tesztelő változat:                                   DO

                                                                                  utasítások

                                                                         LOOP  WHILE  feltétel

pl.        i = 0

            DO

                        PRINT i

                        i = i +1

            LOOP  WHILE  i < 10

            REM  Az i értéke 9 lesz.









Létezik egy  hasonló szerkezetű,  DO  UNTIL  ciklus is, ami addig hajtja végre az utasításokat, amíg a feltétel HAMIS, vagyis igazzá nem válik.





            Elöl tesztelő változat:                                    DO UNTIL  feltétel

                                                                                  utasítások

                                                                       LOOP







            Hátul tesztelő változat:                                  DO

                                                                                  utasítások

                                                                       LOOP  UNTIL  feltétel





7. Állomány kezelés a QBasic -ben







A program által előállított és/vagy felhasznált adatokat állományokban tároljuk.

A QBasic állomány kezelése elég nehézkes, mert nem elsősorban adatfeldolgozásra készült.

A QBasic az adatállományokat   . DAT kiterjesztéssel kezeli.

Az adatállomány több, tetszőleges típusú adat sorozata, de lehet egyetlen adat is.

A QBasic adatállománya  SZEKVENCIÁLIS  ( azaz soros elérésű ).

Az adatállományba felvitt adatsort  az  EOF  ( End Of  File )  jel zárja. Ez jelzi a program számára, hogy az állomány sértetlen.  Az EOF jelnek az adatok kiolvasásakor van jelentősége.

Magasabb verziószámú  QBasic ismeri a véletlen elérésű ( random ) állományt is.





7.1. Új állomány létrehozása





OPEN ”fájlnév.dat”  FOR OUTPUT  AS  #fájlszám





 ”fájlnév”  : a megnyitandó fájl (file) neve.dat   pl. DOKU.DAT

 #fájlszám : a megnyitandó fájl hányadikként lesz megnyitva ebben a programban  ( max. 255 )





pl.        OPEN  ”doku.dat”  FOR OUTPUT  AS  #4

    





Megj.: Ezzel az utasítással egy még nem létező állományt nyitunk meg, azaz új állomány létrehozása történik.

           Az így megnyitott állomány a program bezárása után is létezik, csak nincs benne adat, úgynevezett        „üres állomány” jön létre.



Figyelem !

Ha  OUTPUT -ra nyitunk meg egy már létező állományt, akkor annak tartalma  TÖRLŐDIK  !









7.2.  Már létező állomány megnyitása, utánírás céljából







                                               OPEN ”fájlnév.dat”  FOR  APPEND  AS  # fájlszám





”fájlnév”   : a megnyitandó fájl (file) neve.dat                       pl. DOKU.DAT

 #fájlszám : a megnyitandó fájl hányadikként lesz megnyitva ebben a programban  ( max. 255 )





pl.        OPEN  ”doku.dat”  FOR APPEND  AS  #8

7.3.  Az állomány feltöltése adatokkal







A program futása során, már korábban megnyitott állományba lehet csak adatokat felvinni !



Üres állományba az adat feltöltés történhet a megnyitása után azonnal, vagy bármikor ha bezárását követően ismételten megnyitjuk az OUTPUT utasítással.



Az adatokat tartalmazó állományt nem feltöltjük, hanem tovább bővítjük, így annak megnyitása

 (az utáníró) APPEND utasítás kiadása után lehetséges.





Az adat felvitele a bővített PRINT utasítással történik, amelyben meghatározzuk, hogy melyik, korábban megnyitott állományba történik a felvitel, hányadik a sorban és milyen típusú.





            PRINT  #fájlszám,  [ konstans | változó | kifejezés ] [ , | ;  további konstansok vagy változók ]





#fájlszám:  a megnyitott állomány száma a programban

konstans:   a parancs után beírt numerikus vagy string konstansok

változó:     a programban definiált változó

kifejezés:   a megadott kifejezés értéke

Elválasztó jelek:     ,   - tabulálással ír az állományba

                             ;   - a következő pozíción ír az állományba

A " , "  vagy  " ; " -vel lezárt PRINT utasítás itt is a sorfolytonos adatfelvitelt jelent.





A PRINT utasítással egyetlen adatsor (rekord) jön létre. Több adatsor (több rekord) létrehozásához,  több PRINT utasítást kell alkalmazni, azaz minden újabb PRINT egy új rekordot jelent.

A PRINT utáni adatsort, függetlenül a kiírás módjától (tabulált vagy folytonos), stringnek (karaktersorozatnak) tekinti a program. Ennek beolvasásakor kell gondoskodni a karaktersorozat megfelelő tagolásáról. Ez alól az egyértelműen numerikus adatok lehetnek kivételek, de ezek is beolvastathatók stringként !

A felviendő adatok a PRINT utasításban tetszőleges típusúak és sorrendűek lehetnek, de hozzáférni is csak ebben a sorrendben lehet.





Egyetlen adatsor:   adat1, adat2, adat3,  …  , adatN  EOF



Több adatsor:        adat11, adat12,  …  , adat1M

                             adat21, adat22,  …  , adat2N

                                   . . .

                             adatK1, adatK2,    …  ,  adatKP  EOF               (  M  <>  N  <>  P   )

    



pl.        OPEN "minta.dat"  FOR  OUTPUT  AS  #14

            PRINT  12; "Pista";                                       - figyelje a pontosvesszőt a végén

            PRINT  3; 9; "adat"                                       - itt nincs vessző a sor végén

            PRINT  88, "másik", 6                                              - itt vessző az elválasztó, tehát tabulált

            CLOSE  #14

                      





A  "minta.dat"  állomány tartalma ezek után:



                                   1. rekord:        12  Pista  3  9  adat

                                   2. rekord:        88              másik              6







pl.        OPEN „proba.dat”  FOR  OUTPUT  AS  #6

            FOR  i = 1  TO  12

                        PRINT i ,                                           - figyelje a vesszőt a végén !

            NEXT

            CLOSE  #6







A  "proba.dat"  állomány tartalma:



            Egyetlen rekord, a számot tabuláltan:  1    2    3    4    5    6    7   8    9    10    11   12



Ha a  PRINT  i  után nem lenne a vessző, akkor 12 darab egyetlen számot tartalmazó rekord jönne létre.









7.4.  Adat kiolvasás az állományból





Adatot kinyerni egy állományból csak a szükséges adatokat tartalmazó állomány, olvasásra történő megnyitása után lehet ! Ez azonban még csak az állományhoz való hozzáférést biztosítja. A tényleges kiolvasást külön INPUT utasítással kell kezdeményezni.



 Állomány megnyitása: ( adatkiolvasás - input céljából )



                                   OPEN ”fájlnév.dat”  FOR  INPUT  AS  #fájlszám





”fájlnév” : a megnyitandó fájl (file) neve.kit  pl. DOKU.DAT

#fájlszám : a megnyitandó fájl hányadikként lesz megnyitva ebben a programban  ( max. 255 )





pl.  OPEN  ”doku.dat”  FOR INPUT  AS  #12          





Az adatok kiolvasása lehet:





- SZEKVENCIÁLIS   kiolvasás:   (soros kiolvasás)



INPUT  #fájlszám, változó1,  . . . , változóN





pl.        OPEN  ”nevek.dat” FOR INPUT  AS #2

            FOR  i = 1  TO  10

                        INPUT #2, veznev$, utonev$

                        PRINT veznev$, utonev$

            NEXT



10 x 2 adat kiolvasása és kiírása a nevek.dat állományból, amelyben az adatok a következő sorrendben vannak:

                        NEVEK.DAT {KISS, BÉLA, FA, NÁNDOR, ERŐS, EGON,  . . . }



Az adatok kiolvasása, függetlenül attól, hogy egyetlen folytonos rekordban vagy több rekordban tároltuk el, csakis sorosan  (más néven  szekvenciálisan) lehetséges.

Az  INPUT utasításban a változók felsorolásakor tisztában kell lenni a tárolt adatok típusával is, mert csak a típus jelzéssel együtt lehet hivatkozni az adatra a kiolvasáskor. Stringet csak stringként lehet kiolvasni, a numerikus adat viszont kiolvasható stringként, illetve kiolvasáskor kapja meg a típusát is (pl a& long lesz).

Csakis annyi adatot lehet kiolvasni, ahányat eltároltunk előzőleg. Ha többet próbálunk kiolvasni,

INPUT PAST END OF FILE  hiba üzenettel leáll a program.



Ha ismeretlen az adatok száma az állományban, akkor egy különleges DO WHILE ciklussal olvasunk:



DO WHILE NOT EOF ( n )

       input a$

LOOP



Az utasítás jelentése a következő: olvasson mindaddig egy stringet a #n sorszámú, megnyitott állományból, mindaddig, amíg az olvasáskor nem EOF –fal találkozik.





- meghatározott számú karakter (sztring) kiolvasása:



Ha az állomány egyetlen STRING sorozat, akkor annak „felszabdalásával” rész karakter sorozatok is beolvashatók.

                                               változó$ = INPUT$ ( hossz, #fájlszám )



pl.  a$ = INPUT ( 4, #23 )   - 4 hosszú sztring beolvasása a 23 -iknak megnyitott állományból



            OPEN  ”adatsor.dat”  FOR INPUT  AS #4

            FOR k = 1 TO 7

                        a$ = INPUT$ ( 9, #4)

                        PRINT a$

            NEXT



7 -szer olvas 9 darab karaktert a negyediknek megnyitott állományból, amely a következő:

ADATSOR.DAT {HÉTFŐ----KEDD-----SZERDA---CSÜTÖRTÖKPÉNTEK---SZOMBAT—VASÁRNAP-}



Az adat kiolvasás lehetőségeit a P_74.prg elemzése segít megismerni !

7.5. A megnyitott állomány(ok)  bezárása





A megnyitott állomány(oka)t  BE IS KELL ZÁRNI a programban !





Parancsa:                                CLOSE  #fájlszám     - a # sorszámú állományt             vagy 

                                                CLOSE                     -  az összes nyitott állományt       vagy

                                             

               a programot befejező  END      automatikusan bezár minden állományt.













7.6. Állomány nevek listázása a tároló helyéről





                                   FILES  ” [ drive:\ ] [ útvonal \ ] fájlnév.kit ”





pl.        FILES ” a: \ munka \ program.bas ”

            FILES ” *. dat ”













7.7. Állomány törlése a tároló helyéről





                                   KILL  ” [ drive:\ ] [ útvonal \ ] fájlnév.kit ”





pl.        KILL ” c: \ munka \ program.bas ”

            KILL ” nevsor?? . dat ”











8.  Alprogramok



Az alprogramok, a főprogramtól függetlenül megírt, abban felhasznált önálló, kisebb programok.



Akkor alkalmazzuk, ha a főprogram különböző pontjain azonos műveletsort kell elvégezni. Ilyenkor

egyszer kell csak megírni és ha szükséges egyszerűen meghívjuk az alprogramot, majd ha végzett visszaadja a vezérlést a főprogramnak.



Az alprogramok elkészítése 3 lépésből áll:



1.         Az alprogram megírása

2.         Az alprogram DEKLARÁLÁSA, ami a program elején egy jelzés a program számára, hogy van egy ilyen NÉVEN alprogram a teljes programban.

3.         Az alprogram meghívása illetve meghívásai (az alprogram futtatása) a főprogram megfelelő pontján.



Az alprogramokat a főprogram után – a főprogramot záró  END utasítást követően – kell beszerkeszteni.

Az alprogramok kétfélék:          SZUBRUTINOK     és      FÜGGVÉNYEK





8.1.  Szubrutinok



Szerkezete:                  SUB  szubrurtin-azonosító [ ( param1, param2, …  ) ]

                                               a szubrutin utasításai

                                    END  SUB





Deklarálása:                DECLARE  SUB  szubrutin-azonosító [ ( param1, param2, … ,  ) ]





Hívása:                                   CALL szubrutin -azonosító [ ( param1, param2, …  ) ]        vagy

                                   szubrutin -azonosító  [ ( param1, param2, …  ) ]                   vagy

                                   GOSUB szubrutin -azonosító  [ ( param1, param2, …  ) ]





Paraméter lista csak akkor van, ha a szubrutin paraméterekkel dolgozik.







Alkalmazása   - először is a főprogram elején deklarálni kell  - DECLARE SUB utasítással

                        - megírjuk a szubrutint és a főprogram végére szerkesztjük  (a program záró  END  után)

                        - a főprogramban, ahol kell meghívjuk  névvel  vagy  név nélkül  vagy

                           GOSUB utasítással átugrunk rá







pl.        DECLARE  SUB  szamolas  (paraméterek) - a "szamolas" szubrutin deklarálása

            DECLARE  SUB  nev  (paraméterek)                      - a "nev" szubrutin deklarálása





            a FŐPROGRAM utasításai  . . .



                        CALL  szamolas (paraméterek)         -  a "szamolas" nevű szubrutin meghívása,

                                                                                      lefutása után a vezérlés automatikusan vissza-                                                                                kerül a Főprogram következő utasítására



            a FŐPROGRAM további utasításai  . . .



          

                        szamolas (paraméterek)                      -  a "szamolas" nevű szubrutin meghívása,

                                                                                      lefutása után a vezérlés automatikusan vissza-                                                                                kerül a Főprogram következő utasítására



            a FŐPROGRAM további utasításai  . . .





          

IF  ...   THEN  GOSUB  nev  ELSE  ...                   - feltételes  GOSUB  ugrás a "nev" nevű

                                                                                    szubrutinra

                                                                                    lefutása után a vezérlés automatikusan vissza-                                                                                            kerül a Főprogram következő utasítására

          

            a  FŐPROGRAM további utasításai  . . .





            END                                                                          -  a  Főprogram vége





          

            SUB  szamolas  ( paraméterek)

                        alprogram utasítások

            END  SUB













8.2.  Függvények







Fontos !  A függvény használata hasonlít a szubrutinhoz. A tartalmi eltérés azonban lényeges !

               A függvényre való hivatkozás  (a deklarálás, a meghívás és a létrehozó utasítás 1. sorában)

                        paraméterrel együtt szerepel. Ez a „függvény” független változója.

               A függvény hívásakor mindig egy értékadó utasítás jobb oldalán szerepel a

                        függvény-azonosító ( bemenő érték )

               Eredményül mindig visszaad egy (de csakis egy) értéket a főprogramnak.







Szerkezete:    FUNCTION  függvény-azonosító ( bemenő érték1. bemenő érték2, …  )

                                   a függvény utasításai

                        END  FUNCTION



Deklarálása:    DECLARE  FUNCTION függvény-azonosító ( bemenő érték1. bemenő érték2, … )





Hívása:                       változó-név = függvény-azonosító ( bemenő érték1. bemenő érték2, … )

            

Alkalmazása:  - először is a főprogram elején deklarálni kell

                        - megírjuk a függvényt és a főprogram végére szerkesztjük

                        - a főprogramban, ahol kell meghívjuk







pl.        két szám közül a nagyobbikat kiválasztó függvény



            DECLARE  FUNCTION  Max (x ,y)

          

            INPUT  a

            INPUT  b

            m = Max (a, b)                                     :   REM a függvény meghívása

            PRINT  ”A nagyobb:”,  m

                .           .

            END



            FUNCTION Max (x, y)

                        IF  x >= y  THEN  Max = x  ELSE  Max = y

            END  FUNCTION









Lehetséges egyszerűbb esetben az összevont függvény megadás: - az előző példa összevontan





            DEF FNMax (x, y)

                        IF  x >= y  THEN  FNMax = x  ELSE  FNMax = y

            END  DEF



            INPUT  a

            INPUT  b

            m = FNMax (a, b)                                :   REM a függvény meghívása

            PRINT  ”A nagyobb:”,  m





9.  QBasic függvények    (amelyeket használunk)





Általános szerkezete:



                                   FÜGGVÉNYNÉV  ( argumentum [ további argumentumok ] )







9.1. Matematikai függvények:





9.1.1. Abszolút érték függvény:                                      ABS ( numerikus konstans | változó | kifejezés )



            pl.        PRINT  ABS ( -34.25 )                        34.25





9.1.2. Négyzetgyökvonás függvénye:                              SQR ( numerikus konstans | változó | kifejezés )         



            pl.        PRINT  SQR ( 25 )                   5





9.1.3. Véletlen szám generátor függvény:                                        RND  [ ( argumentum ) ] 



            Az  RND – argumentum nélkül   0  és   1  közé eső számot generál.

            pl.  PRINT  RND                                       0. 567



            Az  RND ( argumentum )   0  és  az argumentum közé eső számot generál.

            pl.   PRINT  RND ( 100 )                           56.7

          

            A feladatnak megfelelően manipulálhatjuk az erdményt:

            pl.    PRINT  INT ( RND * 50 ) + 1           1 és 50  közé eső egész számot állít elő.

                    ( Lásd magyarázatul az INT függvényt a 2.1. pontban. )



Célszerű előtte alkalmazni a   RANDOMIZE TIMER   utasítást azért, hogy ne ugyanazon a kezdő értéken induljon a véletlen szám generálás.





9.1.4. Előjel függvény:  (signum )                 SGN ( numerikus konstans | változó | kifejezés )



Egy szám előjelét adja vissza, ha a szám negatív  -1, ha pozitív  0   formában, amit majd megfelelően felhasználhatunk a programban, például egy feltétel vizsgálatnál.

                      

            pl.  PRINT  SGN ( -12 )                     -1

                  PRINT  SGN ( 87 )                                   0



9.1.5. Szögfüggvények:                     - cosinus számítás                   COS ( szög érték radiánban )          



                                               - sinus számítás                      SIN   ( szög érték radiánban )                     



                                               - tangens számítás                  TAN ( szög érték radiánban )                      





            pl.  pi = 3.14  :  PRINT  COS ( 2 * pi )                                     1

                  PRINT  TAN  ( 3.14 )                                             0







9.2. Numerikus típus konverziós és kerekítő függvények:   számok átalakítása





9.2.1. Konvertálás  INTEGER típusra:                     INT ( numerikus konstans | változó | kifejezés )    



Az argumentumot a kisebb egész számmá alakítja.  Nem kerekítés  Mindig a számegyenesen tőle balra eső egész számot adja vissza.



            pl.        PRINT  INT ( 35. 7 )                  35

                        PRINT  INT ( 35. 2 )                  35   

                        PRINT  INT ( - 89.3                 - 90     !





9.2.2.  Kerekítés  INTEGER típusra:                        CINT ( numerikus konstans | változó | kifejezés )



A kerekítés szabályának megfelelően alakít át egész számmá. A negatív számot előbb kerekíti majd előjelet ad hozzá. Értéke - 32768 és 32767 közötti lehet !



            pl.        PRINT  INT ( 35. 7 )                  36

                        PRINT  INT ( 35. 2 )                  35   

                        PRINT  INT ( - 89.3                 - 89     !

                        PRINT  INT ( - 89.8                 - 90     !



9.2.3.   Konvertálás és egyben kerekítés is  LONG  típusra:          



                                                                       CLNG ( numerikus konstans | változó | kifejezés )

          

          

            Az argumentumot dupla hoszú egész számmá alakítja, a kerekítés szabálya szerint.

            Értéke - 2147483648 és 2147483647 közötti lehet !





9.2.4.  Konvertálás  SINGLE típusra:                       CSNG ( numerikus konstans | változó | kifejezés )



Az argumentum  egyszeres pontosságú, tizedes értékét adja vissza.

9.2.5. Konvertálás  DOUBLE típusra:                      CDBL ( numerikus konstans | változó | kifejezés )

          

            Az argumentum duplapontosságú, tizedes értékét adja vissza.

          





9.2.6. Tizedes szám csonkítás, levágja a tizedeseket:           FIX ( numerikus konstans | változó | kifejezés )



            pl.        PRINT FIX ( 2.5  )                     2

                        PRINT FIX ( - 15.7 )               - 15







9.3. Karakter függvények:





9.3.1. Betűváltó függvények:



            - csupa kisbetűre vált                                                 LCASE$ ( karakter sorozat )    

            - csupa nagybetűre vált                                                         UCASE$ ( karakter sorozat )    



            pl.        PRINT  LCASE$ ( ”AlMa” )                          alma

                        PRINT  UCASE$ ( ”Kiss Matild” )    KISS MATILD







9.3.2. Karakter hossz függvények:





A karakteres kifejezés  n darabszámú karakterét adja vissza.

                        - balról számítva.                                           LEFT$   ( karakter sorozat, n )

                        - jobbról számítva                                           RIGHT$ ( karakter sorozat, n )



            pl.        PRINT LEFT$ ( ”abcdefghijk”, 4 )               abcd

                        PRINT RIGHT$ ( ”abcdefghijk”, 6 )                        fghijk





A karakteres kifejezés n darabszámú karakterét adja vissza a k. kezdő karaktertől.



                                                                                  MID$ ( karakter sorozat, k [ , n ] )



            pl.        PRINT MID ( ”kismikike”, 4, 4 )                   miki







A karaktersorozat karakter darabszámát adja vissza.                       LEN$ ( karakter sorozat )



            pl.        PRINT  LEN ( ”sok a szöveg”)                                 12



9.3.3. Karakter –  ASCII kód átalakító függvények:





- Karaktersorozat első karakterének ASCII számkódját adja vissza.           ASC ( karakter sorozat )



            pl.        PRINT  ASC (”ABC”)                                              65





- ASCII kódot  ( 0 – 255 )  átalakítja karakterré.                             CHR$ ( ASCII - kód )



            pl.        PRINT CHR$ ( 65 )                                       A







9.3.4.  Tabuláló (üres karakter beszúró) függvény:        TAB ( numerikus konstans | változó | kifejezés )

            a numerikus értéke   1  -  255  közé kell, hogy essen



Az aktuális sorban, a kiinduló pozícióról az  n –ik pozícióra állítja a következő kiíratás kezdő pozícióját. Ha az aktuális sorban már az  n –ik  pozíción túl van a kiinduló pozíció, akkor a következő sor  n –ik pozíciójára tabulál.







9.3.5.  Meghatározott számú szóköz kiíratása:                SPC ( numerikus konstans | változó | kifejezés  )

            a numerikus érték   1  -  32767255  eshet



A kiírató utasításban  n  darab space kiíratása.

          

            pl.  a = 30

                  PRINT  „Mákos”;  SPC ( a / 2 );  „tészta”                          Mákos              tészta





9.3.6.  Szóköz karaktersorozat kiíratása vagy definiálása:

     



                                  [ változó$ = ]  SPACE$ ( numerikus konstans | változó | kifejezés )

          

a numerikus érték   1  -  32767255  eshet



            - Karakteres üres karakter sorozat definiálása (megadása) még a kiíratás előtt

            pl.  a$ = SPACE$ ( a / 2 + x )

                   PRINT  „Macska”; a$; „füle”                                Macska            füle



            - Karakteres üres karakter sorozat megadása a kiíratás közben:

            pl.  PRINT  „Macska”; SPACE$ ( a / 2 + x ); „füle”                Macska            füle

9.4.  Numerikus  karakteres átalakítás függvényei:







9.4.1.  Numerikusból, karakteres konvertálás:            STR$ ( numerikus konstans | változó | kifejezés )



            pl.        x = 43.8 : y$ = STR$ ( x ) : PRINT y$                       43.8    ( ez már szöveg ! )







9.4.2.  Karakter sorozatból, numerikussá konvertálás:                     VAL ( karakter sorozat )







Természetesen csak számokat tartalmazó karaktersorozat konvertálható.

Ha a karaktersorozat számokkal kezdődik és betűk is vannak benne, akkor csak az első betűig

alakítja át.

Ha a teljes karaktersorozat betű illetve már a legelső karakter is betű, akkor  numerikus nullát ad vissza.

Ha számok között üres karakterek vannak, akkor a számokat összevonva írja ki.





            pl.        a$ = ”555.5” : PRINT  VAL ( a$)                  555.5

                        b$ =”123alsó56vb”  :  PRINT  VAL (b$ )     123

                        c$ =”xyvz” : PRINT : VAL ( c$ )                   0

                        d$ =”123    45sdf78” : PRINT VAL ( d$)     12345





Pascal programozási nyelv



A Pascal programozási nyelv Blaise Pascalról (1623-1692) kapta nevét, aki francia filozófus és matematikus volt. Tehetségéről árulkodik, hogy 19 éves korában egy összeadni és kivonni tudó mechanikus számológépet készített.



N. Wirth 1968-ban definiálta a Pascal nyelvet, melyet főként tudományos műszaki problémák megoldására tervezett. A Turbo Pascal nyelvet a Borland cég fejleszti 1982 óta elsősorban az IBM PC-kre

A program szerkezete

Programfej



A program kulcsszóval kezdődik, melyet a program neve követ. A program logikai neve a program azonosítására szolgál. Ezt a nevet más programelem azonosítására nem használhatjuk. A program nevének megadását követően a USES alapszó után sorolhatjuk fel a programban használni kívánt egységeket. Az egység (unit) nem ebben a programban deklarált konstansok, változók, eljárások, függvények gyűjteménye.

Deklarációs rész



Itt deklaráljuk azokat a változókat, amelyekkel a program dolgozni fog. A var (variable=változó) kulcsszó jelzi, hogy változó deklarálása következik. A változót úgy deklaráljuk, hogy neve után kettősponttal elválasztva megadjuk a típusát. A deklarációt pontosvessző zárja. Az ugyanolyan típusú változók deklarációját összevonhatjuk úgy, hogy azok azonosítóit vesszővel elválasztva felsoroljuk. Két különböző változónak nem adhatjuk ugyanazt a nevet.

Programtörzs



Ez a végrehajtandó rész. Begin kulcsszóval kezdődik és az end szóval zárul. A program végét az end után álló pont jelzi. A program utasításait a begin és az end közé írjuk. Az utasításokat pontosvesszővel választjuk el egymástól.







Legfontosabb fogalmak:

    programfej, deklarációs rész, programtörzs, deklaráció, unit

Kérdések, feladatok:



    Milyen részekből áll egy Pascal nyelvű program?



    Mi a szerepe a deklarációs résznek?



    Mivel választjuk el az utasításokat egymástól?



vissza

Típusok

Egész számok





 Byte    1 byte              0..255

 Shortint           1 byte              -128..127

 Word  2 byte              0..65535

 Integer            2 byte              -32768..32767

 Longint           4 byte              -2 31..2 31-1

Valós számok





Single 3+1 byte

Real     5+1 byte

Double            6+2 byte

Extended        7+3 byte



A real típus megkötések nélkül használható. A többi típus csak numerikus társprocesszorral vagy annak emulálásával léptethető működésbe {$N+, $E+}. Egy osztás eredménye mindig valós típusú!



Műveletek



1 operandusú: + -



2 operandusú: + - * /



összehasonlítások: < > =

Karakterek



Char: értékkészlete az ASCII karakterkészlet. Ebben a típusban a [0..255] intervallumban minden egész számhoz egy karaktert rendelünk. A karakterek 1 bájtot foglalnak el a memóriában.



Műveletek: összehasonlítások a karakterek sorszáma alapján



Függvényei



ord: ASCII-kódot ad vissza



chr: karaktert ad vissza

Felsorolt típus



Azokat az adattípusokat tartalmazza, melyeket a felhasználó hoz létre, azok neveinek felsorolásával. Sorszáma a felsorolásbeli sorszám. A sorszámozás a 0-val kezdődik. A felsorolt nevek nem szerepelhetnek beolvasó vagy kiíró utasításban. Használhatjuk az összehasonlító műveleteket.



pl.: nyelv : (magyar, angol, nemet, francia);

Intervallumtípus



Az intervallumtípus esetén egy már definiált, sorszámozott típus részsorozatát határozzuk meg. MEg kell adni az intervallum alsó és felső határát. Az intervallum elemeinek sorszáma az eredeti típusban levő sorszám.



Műveletei: az eredeti típuson végezhető műveletek



Függvényei: a sorszámozott típusok függvényei



pl.: betu: 'a'..'z';

Logikai típus (boolean)



Kétféle értéket vehet fel: igaz vagy hamis értéket. A hamis (false) sorszáma 0, az igaz (true) sorszáma pedig 1. Tárolása 1 byte-on történik. A logikai műveleteknél (AND, OR, NOT, XOR) az operandusok és az eredmény is logikai típusú.

Összetett típusok



a) String: karakterlánc, maximális hossza 255 karakter lehet. A karakterlánc elemeire úgy hivatkozunk, mint a tömb elemeire (pl. s[1] az s string első karakterét jelenti). A string 0. eleme a karakterlánc aktuális hosszát tartalmazza.



Műveletei



összefűzés: pl. 'alma'+'fa'='almafa'



összehasonlítás: < > =



Függvényei közül leggyakrabban a length(s) függvénnyel találkozunk, mely az s karakterlánc hosszát adja meg.



b) Array: tömb, azonos típusú elemeket tartalmaz.



Az indextípus a longint kivételével minden sorszámozott típus lehet. Az indextípus gyakran intervallumtípus. Az intervallum első eleme nem lehet nagyobb az utolsó elemnél. Az indexek számát a tömb dimenziójának nevezzük. (Az egydimenziós tömböt vektornak, a kétdimenziós tömböt mátrixnak is nevezzük.) A komponensek a tömb elemei. Az elemtípus a fájltípus kivételével bármilyen típus lehet. Az elemekre indexeikkel hivatkozhatunk. A tömb elemei a memóriában sorfolytonosan foglalnak helyet.



nev: array [indextípus] of elemtípus;



c) Record: rekord, különböző típusú elemek tárolására alkalmas. A rekordon belüli mező-azonosítóknak egyedieknek kell lenniük. Ha azonos nevű változó van a programban, akkor attól megkülönböztethető a rekord ugyanolyan nevű mezője, mert másképp kell rá hivatkozni. A rekord mezőire úgy hivatkozunk, hogy a rekordváltozó neve után ponttal elválasztva írjuk a mező nevét (azonosítóját).



A rekord neve értékadó utasításban is szerepelhet, ha teljesül az értékadás kompatibilitás (a kifejezés bal oldalán álló változóba csak akkor tehetjük a jobb oldal értékét, ha az elfér a változóban).



A mezőlista két részből állhat: fix és változó részből. Ha van változó része a mezőlistának, akkor azt a mezőlista végén helyezzük el.



A változó rekord deklarációjának lényegét a CASE szerkezet adja. Végére ebben az esetben nem kell END, mert a szelektormező minden lehetséges értékét fel kell sorolni.



A WITH utasítás: WITH rekordnev DO utasítás. A DO utáni utasításon belül a program a WITH alapszó után írt rekorddal dolgozik. Így nem kell a rekordnevet ismételgetni a mezőnevek előtt. A WITH utasítás érvényessége a WITH után felsorolt rekordok aktuális értékeire és csak a DO utáni utasításra vonatkozik.



Legfontosabb fogalmak:

    operandus, operátor, char, string, boolean, array, tömbdimenzió, komponens, record, értékadás kompatibilitás, szelektormező

Kérdések, feladatok:



    Melyik típusoknál szükséges a numerikus társprocesszor?



    Milyen egyszerű típusai vannak a Pascal nyelvnek?



    Melyek a Pascal-ban használható összetett típusok?



    Mi a különbség a char és a string típusok között?



    Mi a különbség és a hasonlóság a tömb és a rekord típus között?



vissza

Vezérlési szerkezetek

Szekvencia



Utasítások egymás utáni végrehajtása.

Szelekció



Kiválasztás. Megvalósításai:



    HA - AKKOR - KÜLÖNBEN:



    IF feltétel THEN utasítás1 ELSE utasítás2



    Ha a feltétel igaz, akkor az utasítás1 végrehajtódik, ha nem igaz, akkor az utasítás2 fog végrehajtódni.



    Többágú elágazás:



    CASE szelektormező OF



        Érték1: utasítás1;



        Érték2: utasítás2;



        ...



    END;



Iteráció



Ciklus. Megvalósításai:



    FOR ciklus (növekményes ciklus)



    A ciklusmagot egy előre meghatározott számszor hajtjuk végre.



        Pl.: for i := 1 to 10 do writeln('HELLO');



    i: ciklusváltozó, csak sorszámozott típusú változó lehet (egész szám, karakter, logikai)



    A ciklusváltozó csökkenhet is, ilyenkor a TO helyett a DOWNTO kulcsszót alkalmazzuk.



    Az értékhatárokat és a ciklusváltozót a ciklusmagban megváltoztatni tilos!



    WHILE feltétel DO



    A program a ciklusba való belépés előtt megvizsgál egy feltételt - ezt belépési feltételnek nevezzük -, és ha ez teljesül, akkor a ciklusmag végrehajtódik, egyébként nem. A ciklusmag ismételten végrehajtódik, amíg a belépési feltétel teljesül. Ha már nem teljesül, akkor a vezérlés a ciklus utáni utasításra kerül.



    A WHILE-ciklusnak a végrehajtás feltételét meg kell tudni változtatnia. Ha a feltétel sosem válik hamissá, akkor a ciklusból való kilépés reménytelen. Ilyenkor végtelen ciklusról beszélünk. A feltétel megváltoztatása általában a ciklusmag dolga. Meg kell adnia a lehetőséget, hogy a feltétel hamis is lehessen.



    A WHILE-ciklus olyan problémák megoldására való, ahol az induló feltételek határozzák meg a ciklusmag végrehajtásának szükségességét.



    REPEAT ciklus



    Hátultesztelő ciklus esetén a ciklus magja egyszer mindenképpen végrehajtódik, majd a ciklus végén történik egy feltételvizsgálat, ami eldönti, kiléphetünk-e a ciklusból. Ebben az esetben a feltételt kilépési feltételnek nevezzük.



        REPEAT



        Utasítások



        UNTIL feltétel;



    A REPEAT és UNTIL kulcsszavak több utasítást is közrefoghatnak, így nem kell azokat utasítás-zárójelbe tenni. Ha a feltétel igazzá (!) válik, kilép a ciklusból.



   



Legfontosabb fogalmak:



    szekvencia, szelekció, iteráció

Kérdések, feladatok:



    Mit jelent a szekvencia?



    Milyen megvalósításai vannak a szelekciónak?



    Hol találkozunk belépési feltétellel?



    Milyen problémák esetén alkalmazzuk a while-ciklust?



    Melyik az a vezérlési szerkezet, ahol a ciklusmag egyszer mindenképpen lefut?



vissza

Kiíró és beolvasó utasítások

Kiíró utasítások



write, writeln: kiíró utasítások. A writeln a kiírás végén sort emel. A write és writeln utasításoknak bármennyi paramétere lehet, a paramétereket vesszővel választjuk el egymástól. A paraméterek kifejezések is lehetnek. A paraméter nélküli writeln eljárással sort emelhetünk. Minden paraméter után megadhatjuk, hogy milyen hosszon történjen a kiírás. Ha a megadott hossz nagyobb, mint a kiírandó karakterek száma, akkor jobbra ütköztetés történik. Ha kisebb, akkor a hossz felülbírálódik és kiírja az összes karaktert. Számok esetén egy második hossz is megadható, ez a tizedesjegyek száma.

Beolvasó utasítások



read, readln: segítségükkel adatokat olvashatunk be a memóriába. Amikor a program vezérlése ehhez az utasításhoz ér, akkor a billentyűzeten leütött karakterek megjelennek a képernyőn, s azokat az Enter leütéséig szerkeszthetjük. Az Enter leütésekor a begépelt karakterek bekerülnek a paraméterként megadott változóba. A begépelt karaktersorozat átmenetileg egy billentyűzet-pufferbe kerül. Itt maximálisan 127 karakter fér el. A readln eljárás a feladat végrehajtása után a pufferben maradt szemetet kitakarítja. A paraméter nélküli readln eljárás vár egy bevitelt, majd üríti a puffert.



Legfontosabb fogalmak:



    billentyűzet-puffer

Kérdések, feladatok:



    Milyen kiíró utasítások vannak Pascal-ban?



    Mi a különbség a write és a writeln között?



    Mi történik, ha a writeln után megadott hossz nagyobb, mint a kiírandó karakterek száma?



    Hány karakter fér el a billentyűzet-pufferben?



    Mi a szerepe a billentyűzet-puffernek?



vissza

Eljárások, függvények

Alprogramok



Az alprogram egy olyan névvel ellátott utasításblokk, amelyet valamilyen konkrét feladat elvégzésére készítünk. Az alprogramot a program különböző helyeiről a neve segítségével aktivizáljuk, hívjuk. Az alprogram a hívás hatására a benne rögzített feladatot végrehajtja, majd visszaadja a vezérlést a hívó programnak. Alprogramokat akkor célszerű írni, ha



    bizonyos tevékenység többször előfordul a programban;

    a program tevékenységét és kódolását felosztottuk önálló részfeladatokra;

    a túl nagy programot tagolni, olvashatóságát növelni szeretnénk.



Az alprogramok önmagukban nem használhatók. Egy alprogramot aktivizáló programot meghajtóprogramnak, keretprogramnak vagy hívóprogramnak nevezünk. Azok a programok, amelyek másik programon belül nem használhatók, csak önállóan, főprogramok. Nemcsak főprogram hívhat alprogramokat, hanem alprogram is, sőt alprogram is hívhatja saját magát.



A meghajtóprogram a hívással egy időben információt is átadhat az alprogramnak, amit az alprogram feldolgoz, majd visszatéréskor visszaadhatja a hívóprogramnak. Az információátadást paraméterekkel valósítjuk meg.



Kétféle alprogramot használhatunk a Pascal programnyelvben: eljárásokat és függvényeket.

Eljárások



Az eljárások feladata egy meghatározott, önmagában is értelmes tevékenység elvégzése. Az alprogramot a hívóprogram blokkjában, a deklarációs részben definiáljuk.



A definíció az eljárásfejjel kezdődik. Az eljárásfejet a procedure alapszó vezeti be, majd az eljárás neve, utána - ha vannak - zárójelben a paraméterek leírása következik, melyek az eljárás és a hívóprogram információs kapcsolatát határozzák meg. A definícióban szereplő paramétereket formális paramétereknek nevezzük. A formális paraméterek megadásával jelezzük, hogy az eljárásnak milyen információkat kell kapnia a hívóprogramtól a híváskor, és milyen értékeket juttat vissza a főprogramnak, ha elvégezte feladatát.



    Procedure név ( formális paraméterek ) ;



Az eljárásfej után az eljárásblokk következik, amely tartalmazhat deklarációkat. A formális paramétereket nem kell deklarálni. Begin és End között a tevékenység leírása, az eljárástörzs következik.



Az eljárás hívásakor az eljárás nevét adjuk meg, és a formális paraméterek helyébe a hívóprogram-egység objektumait, az aktuális paramétereket helyettesítjük. Az aktuális paraméterek számának, sorrendjének és típusának meg kell egyeznie a formális paraméterekével.



Léteznek paraméter nélküli, érték szerint, illetve cím szerint hívott paraméteres eljárás. A paraméter nélküli eljárások mindig ugyanazt a műveletet végzik. Ha egy paraméter nélküli eljárás működését kívülről szeretnénk vezérelni, akkor globális változókat használhatunk az eljárással való kommunikációra. (Az ilyen eljárások használata kerülendő!)



Az értékszerinti paraméterátadás csak egyirányú kommunikációt tesz lehetővé a hívó program és a hívott eljárás között. Eljáráshíváskor minden egyes aktuális paraméter értéke a paraméterlista azonos helyén álló formális paraméterbe másolódik. A fordítóprogram az eljárás hívásakor ellenőrzi, hogy az aktuális és a formális paraméterek szám, típusa megegyezik-e.



Abban az esetben, ha az eljárásnak nem küldeni akarunk értéket, hanem azt szeretnénk, hogy egy új értéket adjon, akkor változó-paramétereket kell használnunk. Ilyen például a readln(x) eljárás is. Az is előfordulhat, hogy egy változó értékét meg akarjuk változtatni az eljárással - erre az inc(i) a példa. Ilyenkor nem értéket adunk át az eljárásnak, hanem a változó 4 bájtos címét. Példa a cím szerinti paraméterátadásra:



    Procedure szoroz(var mit:integer; szorzo:integer);



        Begin



        Mit:=mit*szorzo;



    End;



Függvények



A függvény nagyon sok dologban hasonlít az eljáráshoz. Szerkezete:



    Function nev (paraméterlista) : típusazonosító; (függvény feje)



    Var ... (deklarációs rész)



        Begin



        ...



        Nev : = kifejezés; (végrehajtó rész)



    End;



Amikor egy függvényt meghívunk, ugyanúgy végrehajtódik a függvény blokkja, mint az eljárásnál. A paraméterekre és a lokális változókra ugyanazok a szabályok érvényesek.



Különbség: a függvény mindig visszaad egy értéket. A függvényhivatkozás maga jelenti az értéket, azokat általában kifejezésekben használjuk.



Szabályok:



    a függvény mindig visszaad egy értéket

    a függvény csak egy értéket adhat vissza

    a visszaadott értékre a függvény nevével hivatkozunk

    a visszaadott érték típusa csak sorszámozott, valós, karakterlánc vagy mutató lehet



A függvény blokkjában legalább egyszer mindenképpen szerepelnie kell egy értékadó utasításnak, melynek bal oldalán a függvény neve áll, jobboldalon pedig egy kifejezés. Ekkor kap a függvény értéket.



Legfontosabb fogalmak:



    alprogram, hívó program, eljárás, függvény, formális paraméter, aktuális paraméter, érték szerinti paraméterátadás, cím szerinti paraméterátadás

Kérdések, feladatok:



    Mi az alprogramok szerepe?



    Mi jellemző az alprogramokra?



    Mi a különbség az eljárások és a függvények között?



    Milyen összefüggés van a formális és az aktuális paraméterek között?



    Mikor kell egy paramétert cím szerint átadni? Hogyan történik ez?



    Hogyan kap egy függvény értéket?



    Mennyi értéket ad vissza egy függvény?



    Milyen típusú lehet a visszaadott érték?