Bevezetés – a QBASIC programozási nyelv

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 QBasic 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 ( -2¹⁶ és 2¹⁶-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 ( -2³² és 2³²-1 )

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

DE ! Kerekítés itt is.

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 * 10⁷ 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.

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

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 2¹⁴.

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

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.

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

PRINT ”Érték:”, k

. ------- ez a ciklusmag

További utasítások

- 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

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 !

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$

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$

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

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

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

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

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

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

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

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

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

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

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

LOCATE [ sor ] , oszlop

Szín – magyar

Szín - angol

GOTO címkenév

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

IF logikai kifejezés1 THEN

utasítás1

ELSEIF logikai kifejezés2 THEN

utasítás2

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

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

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