A Pascal program szerkezete

A Pascal program szerkezete

A Pascal programot három fõ részre oszthatjuk:
    - programfej
    - deklarációs rész
    - programtörzs

1. Programfej: Mindössze esztétikai célokat szolgál. Itt adhatjuk meg egy szóban a program nevét. Nem kötelezõ szerepelnie a programban.

2. Deklarációs rész: A Pascal nyelv erõsen típusos nyelv, ami azt jelenti, hogy egy programban minden változót, melyet használni szeretnénk deklarálnunk kell, azaz elõre meg kell határoznunk a nevét és a típusát. Ezek a jellemzõk kés& 252d39c otilde;bb a program futása alatt természetesen nem változhatnak. A deklarációs részben történik a használni kívánt változók felsorolása, illetve típusuk meghatározása. Ezen kívül a deklarációs részben szerepelnek a program futása során alkalmazott konstansok (állandók), az általunk létrehozott típusok, az általunk létrehozott eljárások, függvények, és az ugró utasítás esetén alkalmazott címkék is. A deklarációs részhez szokás kapcsolni a unit-ok hívását is.

3. Programtörzs: Másnéven végrehajtási rész. A programtörzs tartalmazza a program utasításait.

program Programnév;

uses Unit_1, Unit_2, ..., Unit_n;

label Cimke_1, Cimke_2, ..., Cimke_n;

type Tipus1= tipusleírás1;      Tipus2= tipusleírás2;

const Konstans1= érték1;        Konstans2= érték2;

var Változó1: tipus1;     Változó2: tipus2;

function Függvény1[(Paraméterlista)]: Tipus1;

procedure Eljárás1[(Paramáterlista)];

begin    utasítás_1;    utasítás_2;    utasítás_n end.

    A programon belül majdnem bárhol elhelyezhetünk magyarázó szöveget, megjegyzést. A megjegyzések olvashatóbbá teszik a programot, érdemes rászokni a használatukra. A néhány szóból álló magyarázó szöveg nagyon megkönnyíti a program esetleges késõbbi módosítását. A megjegyzést vagy (*...*) zárójelek között kell elhelyezni a programsorok között.
 

Néhány szóban a unit-okról:

    A Pascal nyelv utasításkészlete viszonylag kevés utasításból épül fel, mégis igen sokoldalúak a nyelv által biztosított lehetõségek. A nyelv ugyanis a kevés utasítás mellett rengeteg eljárást és függvényt biztosít számunkra.
    A unit-ok feladata az eljárások, függvények tárolása. Ezek az elõre definiált eljárások, függvények szerves részét képezik a Turbo Pascal rendszernek, alapvetõ mûveleteket végeznek (írás a képernyõre, olvasás a billentyûzetrõl, a képernyõ törlése, stb.). A unit-ok csoportokba szedve tartalmazzák az eljárásokat, függvényeket (például: a Graph unit-ban található az összes olyan eljárás és függvény, amely a grafikus képernyõ kezelését végzi), nekünk csak azokat a unit-okat kell beépíteni a programunkba, amelynek az eljárásait, függvényeit használni szeretnénk. Ezeket a unitneveket kell megadnunk a Uses kulcsszó után.
 

Címkék:

    A Pascal programban használhatjuk (bár nem célszerû) a Goto utasítást, amely az általunk megadott címkéhez ugrik, itt folytatva a program végrehajtását. A programban elhelyezni kívánt címkéket szintén elõre deklarálni kell a Label kulcsszó után. A címkéket egyszerûen fel kell sorolnunk. Címke azonosítóként nem használhatjuk a foglalt szavakat.
 

Típusdeklarációk:

    A Pascal nyelv lehetõvé teszi, hogy saját magunk állítsunk elõ új adattipusokat a standard adattipusok felhasználásával. Az általunk elõállított típusok kapnak egy azonosítót, amellyel a változók (tipusos konstansok) deklarációja során erre a tipusra hivatkozni tudunk. Azonosítóként nem használhatjuk a foglalt szavakat.

Példa:
    Program pelda;
    Type Szamtomb= array [1..10] of Integer; 

    Var A: Szamtomb;
           I: Byte;
    Begin
       For I:=1 to 10 do
            Begin
        Writeln('A(z) ', I, '. szam: ');
        Readln(A[I]);
            End;
        .
        .
        .
    End.
 

    A példában egy 10 elemû Integer értékeket tartalmazó tömböt definiáltunk Szamtomb azonosítóval. A saját típusok áttekinthetõbbé teszik a programot, amennyiben bonyolult tipusokkal dolgozunk.
    A tipusdeklaráció jelentõsége azonban a függvények, eljárások alkalmazásakor tapasztalható. A függvények, eljárások paraméterei, és visszatérési értéke csak egyszerû tipus lehet. Hogyan adhatunk át egy 10 elemû tömböt mégis egy függvénynek:

Példa:

Program Osszegez;

Type Szamtomb= Array [1..10] of byte;

Var A: Szamtomb;

Function Sum(T: Szamtomb): Integer;
Var I: Byte;
      O: Integer;
begin
    O:= 0;
    For I:= 1 to 10 do
        O:= O+T[I];
    Sum:= O;
end;

begin
       For I:=1 to 10 do
            Begin
        Writeln('A(z) ', I, '. szam: ');
        Readln(A[I]);
            End;
       Writeln('A tomb elemeinek osszege: ', Sum(A));
end;
 

    Programunkban a Sum függvény segítségével összegezzük a beolvasott A tömb elemeinek értékét, majd kiiratjuk az eredményt. Ha a Sum függvény deklarációjánál összetett tipust alkalmaztunk volna, hibaüzenet keletkezett volna a fordítás közben. Rossz példa (így soha!!!):
    Function Sum(T: Array [1..10] of Byte): Integer;

    Látható tehát, hogy a problémát csak úgy lehetett megoldani, hogy egy saját tipust deklaráltunk hozzá, amelyet a fordító már egyszerû tipusként értelmez.
 

Konstansok:

    A konstansok segítségével szintén áttekinthetõbbé tehetjük a programunkat. A konstansok értéke a program futása során nem változhat meg. Olyan értékeket célszerû (és ésszerû) konstansként deklarálni, amelyek a program során többször is elõfordulnak. Konstans azonosítójaként nem alkalmazhatjuk a foglalt szavakat.

Példa: Számítsuk ki az R sugarú kör kerületét és területét !

Program Kor;
Const PI= 3.14;
Var R: Real;
      K, T: Real;
Begin
    Write('A kor sugara: ');
    Readln(R);
    K:= 2*R*PI;
    T:= R*R*PI;

    Writeln('A kor kerulete: ', K:8:2);
    Writeln('A kor terulete: ', T:8:2);
End.
 

    A példában a PI értékét konstansként definiáltuk, ezzel a programunkat olvashatóbbá téve.
 
    A konstansok és a változók közötti másik fontos különbség (amellett, hogy a konstansok értéke nem változhat) a memóriában való tárolás során jelentkezik. A változók az adatszegmensen vagy a veremben jönnek létre, aszerint, hogy a fõprogram, vagy egy alprogram használja õket. Ezzel szemben a konstansok a kódszegmensben kerülnek elhelyezésre.
    A fenti szabály alól egyetlen kivétel a tipusos konstans, amelyet tulajdonképpen kezdõértékkel ellátott változónak tekinthetünk. Értéke a program futása során megváltozhat, de - a változókhoz hasonlóan - csak a tipus által meghatározott értékeket vehet fel. A tipusos konstans deklarálása a többi konstanssal együtt történik. Példa:

    Const A=10;
      B=11;
      PI=3.14;
      J: Byte= 1;

    A végrehajtási részben a J azonosítót úgy használhatjuk, mint bármely deklarált változót, annyi különbséggel, hogy J már rendelkezik kezdõértékkel, míg a válzozók értéke határozatlan (amíg a fõprogramon beül nem adunk nekik kezdõértéket).
 

Változók deklarálása:

    A program során használni kívánt változókat deklarálnunk kell, azaz meg kell határoznunk a változó tipusát. A változó tipusa befolyásolja, hogy a fordító a memóriában mennyi helyet foglal a változó számára, illetve azt, hogy milyen értéket kaphat a változó a program futása során. A változók deklarációja a Var kulcsszóval bevezetett részben történik. Formája:
    Var azonosító: tipus;
Tehát elõször a változó azonosítóját kell meghatároznunk, majd kettõsponttal elválasztva a tipusát. A változók tipusa csak (a fordító számára) ismert tipus lehet, azaz ha a változó tipusa nem a standard típusok közül kerül ki, a saját tipust elõzõleg deklarálni kell. (Lásd a tipusdeklarációknál.) A változók azonosítójaként nem alkalmazhatjuk a foglalt szavakat.

Példa:

    Var A: integer;
           S: string;
           I: byte;
 

Függvények, eljárások:

    Az alprogramok delkarálása (definiálása) szintén a delkarációs részhez kapcsolódik. Ha a programunkat modulárisan szeretnénk felépíteni, akkor az egyes részfeladatok elvégzését külön eljárások, függvények segítségével végezzük. A deklarációs részben (tehát a felhasználási rész, a fõprogram elõtt) deklarálnunk kell legalább az eljárások, függvények fejét. A fõprogramban csak olyan függvényeket, eljárásokat hívhatunk meg, amelyeknek már legalább a neve ismert a fordító számára. A függvények neve nem lehet foglalt szó, és általában nem célszerû a standard unit-ok függvényeinek nevét alkalmazni, mert ezesetben csak speciális módon tudjuk megkülönböztetni a két függvényt (eljárást). Általában az alprogramok fejével együtt a deklarációs részben történik az alprogram törzsének (végrehajtási részének) kifejtése. Példa:

Program Eljárások;

Var A, B: Integer;

Procedure Kivonas(X, Y: Integer);
Begin
    Writeln('A ket szam kulonbsege: ', X-Y);
End;

Procedure Osszeadas(X, Y: Integer);
Begin
    Writeln('A ket szam osszege: ', X+Y);
End;

begin
    Write('Az elso szam: ');
    Readln(A);
    Write('A masodik szam: ');
    Readln(B);

    Osszeadas(A, B);
    Kivonas(A, B);
end.
 

A példában két eljárást definiáltunk, amelyek a képernyõre írták két szám összegét, illetve különbségét. Az eljárások végrehajtási részét itt a deklarációs részben írtuk meg, közvetlenül az eljárás fejrésze után. A megoldás mûködik, de nem igazán elegáns.
    Áttekinthetõbb programot kapunk, amennyiben kihasználjuk a Forward opció által biztosított lehetõségeket. Ha az alprogram fejrészének deklarációja után szerepel a Forward kulcsszó, akkor nem kötelezõ azonnal definiálnunk az alprogram végrehajtási részét, ezt bármikor megtehetjük a program késõbbi részeiben, de a fõprogram blokkja, a végrehajtási rész elõtt. Ez a lehetõség szintén az esztétikai szempontok miatt lehet elõnyös, amikor egy nagyobb programot írunk.

Példa:
Olvassunk be 3 nevet egy tombbe! Alakitsuk at a neveket csupa nagybetus formara, majd irjuk ki oket. Az atalakitast es a kiirast egy eljaras segítségével oldjuk meg!

Program Eljaras2;
Type Tomb: Array [1..3] of String;

Procedure NagyBetu(T: Tomb); forward;

Var A: Tomb;
       I: Byte;

Const   Fejlec1= 'Kerek harom nevet';
            Fejlec2= 'A beolvasott nevek nagybetuvel irva:';

Procedure NagyBetu(T: Tomb);
Var J, N: Byte;
      K: Tomb;
Begin
   
    For J:= 1 to 3 do

       
        For N:=1 to length(S) do
            K[J][N]:= UpCaseT[J][N];

   
    For J:=1 to 3 do
        Writeln(K[J]);
End;

Begin
    ClrScr;
    Writeln(Fejlec1);
    For I:= 1 to 3 do
        Begin
            Writeln('Az', I, '. nev: ');
            Readln(A[I]);
        End;

    ClrScr;
    Writeln(Fejlec2);
    NagyBetu(A);
End.
 

A programtörzs:

    A program végrehajtási részének is nevezhetjük, lényegében itt írjuk le, hogy mit fog csinálni a programunk, hogyan és mire használja fel a deklarációs részben deklarált változókat, konstansokat, alprogramokat. Nagyon fontos, hogy a fõprogram mindig a Pascal program végén helyezkedik el. A fõprogram egy Begin utasítással kezdõdik és egy End utasítással zárul. Fontos: a fõprogram végét jelzõ End utasítás után minden esetben pontot kell tenni pontosvesszõ helyett, mivel ez jelzi a Pascal program végét a fordító számára.
 

A Pascal programban minden utasítás végére pontosvesszõt kell tenni, kivétel a Begin utasítás, amely egy blokk kezdetét jelzi, és a fõprogramot záró End utasítás, amelynek a végére pont kerül.
A Pascal programban vegyesen használhatunk kis és nagybetûket, a Pascal fordító ezeket nem különbözteti meg.