eljárások és funkciók. Eljárások és funkciók Pascalban

8. osztály. Programozás bekapcsolva ABC nyelv Pascal

Informatika tanár, NIS, Uralsk FMN Zelenov Boris Aleksandrovich

• A tanulók eljárások és függvények segítségével oldják meg a problémákat
• A tanulók megtanulják megoldani a nagy problémákat azáltal, hogy kisebbre bontják azokat.

• Az eljárások és függvények fogalmának kialakítása programozási nyelvben.

• A hallgatók ismerik az "eljárások" és "függvények" fogalmát, meghatározzák a formai és tényleges paramétereket

Várt eredmények – Leírók:

1. Ismeri az "eljárás" fogalmát

2. Ismeri a "funkció" definícióját

3. Meghatározza a tényleges és formális paramétereket

4. Megkülönbözteti a paraméterértékeket és a változókat

5. Megkeresi egy eljárás vagy függvény hívását a programkódban

Elvira standard terve

1. Távolítsa el a papírokat

2. Öntözzük meg a virágokat

3. Mossa le az íróasztalokat

4. Törölje le az üveget

Algoritmus vége

Hogyan lehetne javítani ennek a folyamatnak a megszervezését?

Óra témája

Rutinok:

Ishki bagdarlam

szubrutin

Eljárás

Eljárás

Parametler

Hasznos kifejezések:

A változók értékeinek az eljárásnak (függvénynek) való átadásához a tényleges paramétereket használják ...

Az eljárás leírásához először ...., majd ...

A szubrutin fogalma

Meghatározás

szubrutin különálló, funkcionálisan független része a programnak.

szubrutinok

Eljárások

• megszünteti annak szükségességét, hogy a program szövegében hasonló töredékeket ismételten megismételjenek;
• javítsa a program szerkezetét, megkönnyítve annak megértését;
• növeli az ellenállást a programozási hibákkal és a programmódosítások során fellépő előre nem látható következményekkel szemben.

• Rajzoljon kerítést egy programozási nyelv segítségével

Ebben a feladatban létrehozhat egy eljárást, amely végrehajtja az algoritmust egy töredék (kerítés) rajzolására, majd folyamatosan hivatkozik erre az eljárásra, megváltoztatva a toll kezdeti helyzetét

• Ismertesse, hogyan kell racionálisan karácsonyfát rajzolni programozási környezetben

• Ezek független programtöredékek, speciális módon megtervezve és saját névvel rendelkeznek.

Kölcsönhatás a főprogram és az alprogram között

blokk diagramm

• Szubrutin hívásblokk (eljárás vagy funkció)

Szubrutin neve (eljárás vagy funkció)

blokk diagramm

Az eljárás leírása így néz ki:

eljárást name(formális paraméterek listája); leírás rész kezdődik operátorok vége ;

A funkció leírása így néz ki:

funkció name(formális paraméterek listája): return type;

leírás rész kezdődik operátorok vége ;

Helyszín a programban

program ...;

//Leírás szakasz Felhasználások, Const, Var, ...

eljárást A ;

kezdődik ....... vége ;

eljárást B ;

kezdődik ........ vége ;

C funkció ;

kezdődik ........ vége ;

//Fő program

kezdődik ........ vége .

• A függvény és az eljárás közötti különbség az, hogy a függvény törzsét alkotó operátorok végrehajtásának eredménye mindig egyetlen érték, így a függvényhívás a megfelelő kifejezésekben használható változókkal és konstansokkal együtt.

Eljárások

Funkciók

Több eredménye is lehet, vagy végrehajthat néhány műveletet

Csak egy eredménye van, melynek típusát a függvény deklarálásakor külön adjuk meg.

Az eredmény bármilyen típusú tömb, karakterlánc, szám stb. lehet.

Az eredmény csak valós, egész vagy karakteres érték lehet.

Az eljáráshívás parancs egy különálló parancs, amelyet önállóan használnak.

A függvényhívás csak a megfelelő típusú kifejezés összetevőjeként használható.

Egy függvény törzsének tartalmaznia kell legalább egy hozzárendelési operátort, amelynek bal oldalán a függvény neve szerepel.

b majd max:=a else max:=b; MaxNumber:= max; end;" width="640"

Eljárás vagy funkció?

MaxNumber(a,b: integer): egész szám;

var max: integer;

MaxNumber:= max;

b majd max:=a else max:=b; end;" width="640"

Eljárás vagy funkció?

MaxNumber(a,b: integer; var max: integer);

ha ab akkor max:=a else max:=b;

Eljárás vagy funkció?

ChangeColor(C1, C2: Word);

TextBackGround (C2)

Eljárás vagy funkció?

Add(X, Y: Integer): Integer;

Tényleges

• A fő program részben jelezve

Hivatalos

• Az alprogramban megadva
• Az alprogramban megadva

Az eljáráshívás a következő formátumú utasítással történik:

eljárás neve (a tényleges paraméterek listája);

• A tényleges paraméterek listája a felsorolásukat vesszővel választjuk el.

• A Pascal nyelvi szabványban a paraméterek kétféleképpen adhatók át - érték szerint és hivatkozással. Az érték által átadott paramétereket hívjuk érték paraméterek hivatkozással átadva - változó paraméterek. Ez utóbbiakat az különbözteti meg, hogy egy eljárás (függvény) fejlécében a var szolgálatszó áll előttük.

Paraméterek átadása. Formális paraméterek

Változók

Értékek

Paraméterek érték szerint

Formális paraméterek

Változók

Formális paraméterek

Paraméterek érték szerint

• Az első módszerben (érték szerint haladva) a tényleges paraméterek értékeit a megfelelő formális paraméterekbe másoljuk.

Eljárás

Név Eljárás (a, b: egész);

Fő program

Ha ezek az értékek az eljárás (funkció) végrehajtása során megváltoznak, a kezdeti adatok (tényleges paraméterek) nem változhatnak

Var c, d: egész szám;

• Referencia szerinti átadáskor minden változás, amely egy formális paraméterekkel rendelkező eljárás (függvény) törzsében történik, azonnali hasonló változáshoz vezet a nekik megfelelő tényleges paraméterekben.

Eljárás

Név Eljárás (a, b: egész szám, Var c: valós);

Fő program

Változások történnek a hívó blokk változóiban, így a kimeneti paraméterek hivatkozással kerülnek átadásra. Meghíváskor a hozzájuk tartozó tényleges paraméterek csak változók lehetnek.

Írsz:

1. Tényleges paraméterek ___________

Eljárás Kvad(R: valós; var S: valós);

2. Formai paraméterek ___________

3. Formális paraméterek-értékek__________

5. Eljárás neve ___________

6. Az eljárás lehívása a programból _________________________

Interaktív feladat

http://www.bzfar.net/load/podprogrammy_procedury_i_funkcii_parametry/23-1-0-498

Elvira az osztályfőnök. Tervet kell készítenie az általános takarításhoz az osztályteremben: vegye le a papírokat, öntözze meg a virágokat, mossa le az asztalokat, törölje le az ablakokat. Mi a legjobb módja a munkájának megszervezésére? Segíts Elvirának.

Elvira Advanced Plan

Rutinok:

Arsen – eltávolítja a papírokat

Mila virágokat öntöz

Vitalij - íróasztalokat mos

Indira - törli az üveget

1. Fuss Arsen

2. Fuss Milát

3. Fuss Vitalit

4. Fuss Indira

Algoritmus vége

• Milyen új struktúrákkal találkoztunk ma a programozási nyelvben?
• Nevezze meg a vizsgált paramétereket!

• Hogyan adják át a paramétereket egy eljárásnak?

• Óra összefoglalója

• Meghatározások keresése: „Helyi változók” és „Globális változók”

• Állítson össze két olyan feladatot, amelyben eljárások vagy függvények használhatók.

• Hogyan határozná meg az óra témáját? (találja ki a saját nevét)
• Mit gondolsz, mit kellene megtanulnod a következő leckében?

Találkozzunk

következő lecke!

Élvezni előnézet prezentációk fiók létrehozása ( fiókot) Google-t, és jelentkezzen be: https://accounts.google.com

Diák feliratai:

Eljárások és funkciók Pascalban. Rekurzió A GBOU 1362-es iskola számítástechnika tanára, Sanina Marina Sergeevna

Szubrutin - a program autonóm része, amely végrehajt egy bizonyos algoritmust, és lehetővé teszi a hozzáférést különböző részekből általános program. A szubrutinok használata lehetővé teszi az egyik legmodernebb programozási módszer - a strukturált programozás - megvalósítását.

szubrutinok eljárás funkció PROCEDURE FUNCTION

A Pascal eljárásai és függvényei a változószekció mögötti leírás részben vannak deklarálva.

A függvényeknek és eljárásoknak vannak paraméterei (változók, amelyek értéket adnak át). Két típusuk van: 1) Formális - azok, amelyek az alprogram leírásában szerepelnek 2) Aktuális - azok, amelyek a fő programból egy függvénybe vagy eljárásba kerülnek át. A tényleges paramétereknek számban, sorrendben és típusban meg kell egyeznie a formális paraméterekkel.

Ezenkívül az alprogramnak vannak változói. akivel továbbra is együtt fog dolgozni. Ismét két típusra oszthatók: 1) Globális változók, azaz a teljes programban hatnak 2) Lokális - azok, amelyek csak egy eljárásban vagy funkcióban működnek.

Eljárások Akkor használatos, ha egy szubrutinnak több eredményt kell elérnie. Kétféle eljárás létezik: paraméterrel; paraméter nélkül.

Az eljárás szerkezete hasonló a programszerkezethez, és egy fejlécből és egy blokkból (eljárástörzs) áll. eljárás ProcedureName; var … begin …//Eljárás törzs vége ; begin // fő programtörzs vége .

Paraméter nélküli eljárások procedúra pr; var i: integer ; kezdődjön az i:=1-től 60-ig do write (‘ * "); writeln ; end . begin pr ; end. Ez a program 60 csillagból álló karakterláncot ad ki.

Eljárás paraméterrel. Írjon programot két c=5 és d=7 szám helycseréjére program obmenDan ; var c,d:integer ; eljárás obmen(a,b:integer); var m:integer; beginm:=a; a:=b; b:=m; writeln(a,b); vége; begin writeln("Írjon be 2 számot: "); readln(c, d); obmen(c,d) ; writeln(c," ",d); vége.

A probléma elemzése 1) ha az obmen eljárást két 5-ös és 7-es paraméterrel hívjuk, akkor az 5-ös és 7-es számok is az a és b változókba kerülnek: с 5 d 7 a 5 b 7

Annak érdekében, hogy a c és d , a és b változók ugyanazokra a memóriacellákra vonatkozzanak (ha a és b értéke változik, akkor a c , d értéke is megváltozik) a formális paraméterek leírásánál, add hozzá a VAR szót a szükséges változók elé: procedúra obmen (var a,b:integer); c 5 d 7 a b

Funkciók A Pascal beépített funkcióinak készlete meglehetősen széles (ABS, SQR, TRUNC stb.). Ha új, nem szabványos funkció kerül a programba, akkor azt a programszövegben le kell írni, ezután lehet elérni a programból. A funkció hívása a hozzárendelési operátor jobb oldalán történik, feltüntetve a függvény nevét és az aktuális paramétereket. Egy függvénynek lehetnek saját helyi állandói, típusai, változói, eljárásai és függvényei. A funkciók leírása Pascalban hasonló az eljárások leírásához.

A függvények megkülönböztető jellemzői: - végrehajtási eredmény - egy érték, amely a függvény nevéhez van rendelve és átkerül a főprogramba; - a függvény neve operandusként szerepelhet a kifejezésben.

Funkció leírása: funkció () : típus; (helyi névleírás szakasz) Begin (futtatható utasítások szakasz) :=; ( kötelező paraméter ) End;

Függvényhívás: := (); 1 . A hozzárendelési operátor jobb oldalán. 2. Egy kifejezésben az elágazó operátor feltételében. 3. A kimeneti eljárásban a függvény eredményeként.

Rekurzió A Pascal-beli eljárások és függvények nevezhetik magukat, pl. rendelkezik a rekurzív tulajdonsággal. A rekurzív függvénynek szükségszerűen tartalmaznia kell egy rekurzív befejezési feltételt, hogy ne idézze elő a program ciklusát. Minden rekurzív hívás új helyi változókészletet hoz létre. Vagyis a hívott függvényen kívül található változók nem változnak.

Készítsen rekurzív függvényt, amely a következőképpen számítja ki egy n szám faktoriálisát: n ! = 1, ha n= 1 n!= (n -1)! n, ha n > 1

függvény f(n: integer): integer ; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát) end ;

Feladatok Módosítsa az a, b, c változók értékeit úgy, hogy azok nem csökkenő sorrendbe legyenek rendezve (a ≤ b ≤ c). Adott n egész szám. Keresse meg közülük azt a számot, amelynek számjegyeinek összege a legnagyobb.

Alprogramok Egy feladatban gyakran meg akarunk ismételni egy bizonyos utasítássorozatot a program különböző részeiben. Annak érdekében, hogy ezt a sorozatot egyszer leírjuk, és sokszor alkalmazzuk, a programozási nyelvekben szubrutinokat használnak. A szubrutin egy speciálisan kialakított programblokk a főprogramban történő további felhasználásra.Az alprogramok használata lehetővé teszi az egyik legmodernebb programozási módszer - a strukturált programozás - megvalósítását.

Az alprogramok három fontos feladatot oldanak meg, amelyek nagyban megkönnyítik a programozást: 1. megszűnik a programszöveg hasonló töredékeinek ismételt ismétlése, pl. csökkentse a program hatókörét; 2. javítsa a program szerkezetét, hogy könnyebben érthető legyen az elemzés során; 3.csökkenti a hibalehetőséget, növeli az ellenállást a programozási hibákkal és az előre nem látható következményekkel szemben a módosítás során.

Eljárások és függvények A Pascalban kétféle szubrutin létezik: eljárás (PROCEDURE) és funkció (FUNCTION). A Pascal eljárásai és függvényei a változószekció mögötti leírás részben vannak deklarálva. Program ProgramName; VAR … // a főprogram változóinak leírása; eljárás ProcedureName; var … begin …//Eljárás törzsének vége; begin //fő programtörzs vége.

A függvényeknek és eljárásoknak vannak paraméterei (változók, amelyek értéket adnak át). Két típusuk van: 1) Formális - azok, amelyek az alprogram leírásában szerepelnek 2) Aktuális - azok, amelyek a fő programból egy függvénybe vagy eljárásba kerülnek át. A tényleges paramétereknek számban, sorrendben és típusban meg kell egyeznie a formális paraméterekkel.

Eljárások Az eljárások akkor használatosak, ha egy szubrutinban több eredményt kell elérni. A Pascalban kétféle eljárás létezik: paraméteres és paraméter nélküli eljárások. Az eljárást az eljárás neve, majd a tényleges paraméterek követik. Egy eljárás meghívásakor egy-egy megfeleltetés jön létre a tényleges és a formális paraméterek között, majd a vezérlés átkerül az eljárásra. Az eljárás végrehajtása után a vezérlés átkerül a hívó program következő, az eljáráshívást követő operátorához.

1. példa: Paraméterek nélküli eljárás, amely 60 csillagból álló karakterláncot nyomtat. eljárás pr; var i: integer ; start for i:=1 – 60 do write(* "); writeln; end; begin pr; end.

2. példa Írjon programot két c=5 és d=7 szám helyének felcserélésére program obmenDan; var c,d:integer; eljárás obmen(a,b:integer); var m:integer; beginm:=a; a:=b; b:=m; writeln(a,b); vége; begin writeln("Írjon be 2 számot: "); readln(c, d); változás(c, d); writeln(c," ",d); vége. c5 d 7 a 5 b 7 a 7 b 5 3) de a c és d változók adatai nem változtak, más memóriasejtekben vannak

Ahhoz, hogy a c és d, a és b változók ugyanazokra a memóriacellákra vonatkozzanak (ha a és b értéke változik, akkor a c és d értéke is megváltozik) a formális paraméterek leírásánál, add hozzá a VAR szót a szükséges változók elé: procedúra obmen (var a,b:integer); c5 d 7 a b

3. példa Adott 3 különböző egész szám tömb (egyiknek mérete nem haladja meg a 15-öt). Minden tömbben keresse meg az elemek összegét és a számtani átlagot. program proc; var i, n, sum: integer; sr: valódi; eljárási munka (r:integer; var s:integer; var s1:real); var mas: egész számok tömbje ; j: egész szám kezdődik s:=0; mert j:=1-től r-ig kezdjük az olvasást(mas[j]); s:=s+mas[j]; vége; s1:=s/r; vége;

(főprogram) begin for i:=1 to 3 do begin write ("Vvedite razmer ",i, " masiva: "); readln(n); munka(n, sum, sr); (munkaeljárás hívása) writeln("Summa elementov = ",sum); writeln("Srednearifmeticheskoe = ",sr:4:1); vége; vége.

A program munkájának eredménye: A program háromszor hívja meg a munkaeljárást, amelyben az r, s, s1 formális változókat a tényleges n, sum, sr váltja fel. Az eljárás elvégzi a tömbelemek bevitelét, kiszámítja az összeget és az átlagértéket. Az s és s1 változókat visszaadjuk fő program, ezért a leírásuk elé a var szolgáltatásszó kerül. A mas, j helyi paraméterek csak az eljárásban érvényesek. Globális - i, n, sum, sr a program egészében elérhetők.

Funkciók Pascalban A Pascal beépített funkcióinak készlete meglehetősen széles (ABS, SQR, TRUNC stb.). Ha új, nem szabványos funkció kerül a programba, akkor azt a programszövegben le kell írni, ezután lehet elérni a programból. A funkció hívása a hozzárendelési operátor jobb oldalán történik, feltüntetve a függvény nevét és az aktuális paramétereket. Egy függvénynek lehetnek saját helyi állandói, típusai, változói, eljárásai és függvényei. A funkciók leírása Pascalban hasonló az eljárások leírásához.

4. példa Írjon fel egy a x fokú szubrutinfüggvényt, ahol a, x tetszőleges szám. Használjuk a képletet: a x = e x egy p2 programban; var f, b, s, t, c, d: valós; ( globális változók) függvény stp (a, x: valós) : valós; variál: valódi; (lokális változók) begin y:= exp (x * ln (a)) ; stp:= y;(a szubrutin számítási eredményéhez tartozó függvénynév hozzárendelése) end; (a függvény leírása kész) begin d:= stp(2.4, 5); (különböző számok és változók számítási hatványai) writeln (d, stp (5,3.5)); read(f, b, s, t); c:= stp(f, s)+stp(b, t); writeln(c); vége.

Funkciók A szubrutin a program egy külön szintaktikai konstrukcióként kialakított és névvel (önálló programblokk) ellátott része az egyes feladatok megoldására. Eljárás leírása: eljárás () (helyi név végrehajtási szakasz) Begin (kimutatás végrehajtási szakasz) Befejezés; Funkció leírása: funkció (): típus; (helyi név deklarációs szakasz) Begin (futtatható utasítás szakasz) := ; (kötelező paraméter) End; Eljárás felhívás: (); Függvényhívás: := (); 1. A hozzárendelési operátor jobb oldalán. 2. Egy kifejezésben az elágazó operátor feltételében. 3. A kimeneti eljárásban a függvény eredményeként. Alprogramok leírása Eljárások

Rekurzió A Pascal-beli eljárások és függvények nevezhetik magukat, pl. rendelkezik a rekurzív tulajdonsággal. A rekurzív függvénynek szükségszerűen tartalmaznia kell egy rekurzív befejezési feltételt, hogy ne idézze elő a program ciklusát. Minden rekurzív hívás új helyi változókészletet hoz létre. Vagyis a hívott függvényen kívül található változók nem változnak.

1 függvény f(n: integer): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát" title="Példa 5. Hozz létre egy rekurzív függvényt, amely egy n szám faktoriálisát a következőképpen számítja ki: n! = 1 ha n= 1 n!= (n -1)! n ha n > 1 f függvény (n: egész): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát" class="link_thumb"> 19 !} 5. példa Írjon egy rekurzív függvényt, amely a következőképpen számítja ki egy n szám faktoriálisát: n! = 1, ha n= 1 n!= (n -1)! n ha n > 1 függvény f (n: integer): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény hívja magát) end; 1 függvény f(n: integer): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (az f függvény meghívja magát"> 1 f függvény (n: egész): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát) end; " > 1 függvény f (n: egész): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát" title="Példa 5 Írjon egy rekurzív függvényt, amely a következőképpen számítja ki n faktoriálisát: n!=1 ha n= 1 n!= (n -1) n ha n > 1 függvény f (n: egész): egész szám;kezdődik, ha n = 1, majd f:= 1 különben f:= n * f (n -1); (f függvény meghívja magát"> title="5. példa Írjon egy rekurzív függvényt, amely a következőképpen számítja ki egy n szám faktoriálisát: n! = 1, ha n= 1 n!= (n -1)! n ha n > 1 függvény f (n: integer): egész szám; kezdődik, ha n = 1, akkor f:= 1 else f:= n * f (n -1); (f függvény meghívja magát"> !}

szubrutinok V TurboPascal

• szubrutin – egy elnevezett, logikailag teljes parancscsoport, amelyből tetszőleges számú végrehajtásra hívható különböző helyeken programokat.

A szubrutinok használatának okai

• a feladat több részfeladatra bontásával (felosztásával) egyszerűsítse a nagy programok fejlesztését;
• a program nagyobb láthatósága;
• memória megtakarítása.

Alprogramok típusai

eljárások

funkciókat

• Eljárás a program egy független elnevezett része, amely meghatározott műveletek végrehajtására szolgál.

Paraméterek nélküli eljárások

• Felvételi formátum :

eljárást ;

vége ;

• A paraméter nélküli eljárásokban használt összes változó leírása a fő programban (a Var modulban található).

Példa . Írjon programot egy henger térfogatának meghatározására.

programhenger;

Var R, H, V: valós;

Beviteli eljárás ; (adatbeviteli eljárás)

Writeln('Adja meg a sugár értékét');

writeln('Adja meg a magasság értékét');

eljárás; { eljárást számításokat hangerő }

V:=PI*sqr(R)*H;

Kimeneti eljárás ; ( kimeneti eljárás )

writeln('V=',V);

Eljárások c paramétereket

• Az eljárások konstansokat, változókat és egyéb eljárásokat írhatnak le.
• Az eljárásokban a leírás rész felépítése megegyezik a főprograméval.
• Lokális változók egy eljáráson belül deklarált változók.
• A lokális változók nem érhetők el az eljáráson kívül.
• Az eljáráson belüli helyi változók változásai nem érintik az azonos nevű, de az eljáráson kívül deklarált változók értékeit.

Eljárások c paramétereket

• Globális változók

Példa .

programfeladat;

Var a, b: egész szám;

eljáráshelyi;

Var a, x: char; Mert eljárások helyi:

kezdődik változó x - helyi változó

a:='! '; (a program nem tudja megváltoztatni az értékét)

b:=b+1; változó b - globális változó

vége ; (a változó értékének minden változása az eljárásban

A BEGIN az eljárásból való kilépés után is megmarad)

b:=100; változó a a főprogramban – egész típus,

helyi; eljárásban pedig - karaktertípus. változó a

writeln('a=', a); egész típus nem érhető el a helyi eljárásban.

writeln('b=',b);

A program végrehajtásának eredménye: a=0; b=101.

); Rajt; vége ; "width="640"

Paraméterek átadása a következőnek Turbó Pascal

• 1. Paraméterek átadása érték szerint

• Érték paraméterek – Az eljárás neve után deklarált változók in zárójelben. Előttük nincs szolgálati szó Var .
• Felvételi formátum :

eljárást (:

változó);

vége ;

• formális paraméterek .
• tényleges paraméterek .

Példa .

program paraméter;

Var m, n: egész szám;

sum Procedure(a, b: integer);

writeln('S=',S);

summa(m,n); vagy summa(100,10);

Változók a És b formális paraméterek és változók m És n - tényleges. Aktuális paraméterértékek m =100 és n =10 átadásra kerül a formális paramétereknek a És b .

A tényleges paraméterek módosítása csak az eljáráson belül történik, és az eljáráson kívül nem érinti azokat.

; változó változó:); Rajt; vége ; "width="640"

Paraméterek átadása a következőnek Turbó Pascal

• 2. Paraméterek név szerinti átadása

• Változó paraméterek – az eljárás neve után zárójelben deklarált változók, amelyeket a Var szolgáltatásszó előz meg.
• Felvételi formátum :

eljárást (:

változó; Var

változó:);

vége ;

b, akkor min:= b; ha min c akkor min:= c; vége ; BEGIN writeln('Írjon be három számot'); readln(a1, b1, c1); writeln (' írjon be három számot'); readln(a2,b2,c2); minimum(a1,b1,c1,min1); minimum(a2,b2,c2,min2); S:= min1 + min2; writeln('S=', S); VÉGE. Példa. Adott két számhármas: a 1, b 1, c 1 és a 2, b 2, c 2. Határozza meg az összeg értékét: S=min (a1, b1, c1) + min (a2, b2, c2) "width=" 640"

Var a1,b1,c1,a2,b2,c2, min1, min2, S: valós;

Eljárási minimum (a,b,c: valós; Var min: valós);

ha min b, akkor min:= b;

ha min c akkor min:= c;

writeln('Írj be három számot');

readln(a1, b1, c1);

writeln (' írjon be három számot');

readln(a2,b2,c2);

minimum(a1,b1,c1,min1);

minimum(a2,b2,c2,min2);

S:= min1 + min2;

writeln('S=', S);

Példa. Adott két számhármas: a 1, b 1, c 1 és a 2, b 2, c 2. Határozza meg az összeg értékét: S=min (a1, b1, c1) + min (a2, b2, c2)

Funkció egy szubrutin, amelynek eredménye valamilyen érték.

• Felvételi formátum :

funkció (:

vége ;

• A függvénytörzsben a függvénynévhez hozzá kell rendelni a végrehajtásának eredményét.
• Amikor egy függvényt hívunk, annak nevét a tényleges paraméterek listájával együtt operandusként kell szerepeltetni a kifejezésben.

programkifejezés;

függvénymodul (a: valós) : valós;

writeln('Adja meg a változó értékét');

y:= modul(x-3) + modul(x+6);

writeln ('y=', y);

Példa . Számítsa ki a kifejezés értékét: y = | x -3 | + | x+6 |

dia 1

3. dia

Alprogramok: Globális és lokális változók Minden alprogramot deklarálni kell egy deklarációs szakaszban. Minden szubrutinnak nevet kell adni. A főprogram és az alprogramok közötti információt globális paraméterek (változók) továbbítják, amelyek a program bármely részében érvényesek és a főprogramban leírt névvel rendelkeznek. Az alprogramon belül helyi paraméterek (változók) használhatók - nevüknek és értéküknek csak az adott szubrutin határain belül van értelme, és nem érhetők el a hívó program számára

4. dia

Formális és tényleges paraméterek Az alprogramok leírásában a paramétereket csak névvel jelöljük, ezért formálisnak nevezzük őket. Amíg az alprogramot meg nem hívják, nincs jelentésük. Csak az aktuális paramétereknek foglalnak helyet, rögzítve azok számát és adattípusát. Aktuális paramétertípusok: Az értékparaméterek azt jelzik, hogy milyen értéket kell hozzárendelni egy adott alprogram-paraméterhez. Az alprogram lejárta után visszatérnek a korábbi értékekhez, még akkor is, ha az alprogramban megváltoztatták őket. A szubrutinban lévő változó paraméterek a formálisak helyére lépnek, értéküket megváltoztathatják az alprogram végrehajtása során és elmenthetik a változtatásokat a szubrutin kilépésekor (a változó paraméterek előtt kulcsszó Var).

5. dia

6. dia

Az eljárás leírása Program Pr1; Const...Type...Var...Procedure(); Leírás Kezdete Eljárás törzse End; Kezdje... (); …vége. Az eljárás meghívásakor a formális paraméterek helyébe a tényleges paraméterek lépnek.

7. dia

Két szám összegének kiszámítására szolgáló eljárás pr1 program; Használja a crt-t; Var a,b,s:real; eljárás summa(x,y:real;var z:real); beginz:=x+y; vége; start clrscr; writeln("Írja be a,b"); readln(a,b); summa(a, b, s); writeln(" számok összege ",a:3:1," és ",b:3:1," = ",s:3:1); readln; vége. x,y,z – formális paraméterek, lokális a,b,s változók– globális változók a,b,s – aktuális paraméterek x y z a b s Paraméter-értékek Paraméter-változó

8. dia

9. dia

10. dia

Számítsa ki az a:=(3n!+2m!)/(m+n) kifejezés értékét! Milyen típusú változókat kell használni a faktoriális megtalálásához? programpr2; Használja a crt-t; Varm,n,x,y,z:integer; a:real; procedúra fact(d:integer;var q:integer); var i:integer; beginq:=1; ha i:=1-től d-ig q:=q*i; vége; start clrscr; writeln("adja meg az n, m értékeket"); readln(n,m); tény(n, x); tény(m,y); tény(m+n,z); a:=(3*x+2*y)/z; writeln("kifejezés értéke, ha m= ",m:4," és n= ",n:4,"egyenlő",a:8:3); readln; vége. N!=1 2 3… N

dia 11

Egydimenziós tömb elemeinek bemeneti kimenete A Random(X) függvény 0-tól X-ig terjedő egész vagy valós típusú véletlenszámot generál (a függvény hívása előtt a Randomize eljárással inicializálni kell). Ha X nincs megadva, az eredmény Real típusú lesz 0,0 és 1,0 között. Véletlenszerű (B-A+1)+A tartományból véletlenszerű egész számokból álló tömb előállítása Feladat: Rendezzük el egy egydimenziós tömb elemeinek bevitelét véletlenszám-generátor segítségével (-10 és 20 közötti értéktartomány), és a az elemek kimenete eljárásként. A=-10 esetén B=20 véletlenszerű(20-(-10)+1)+(-10)

12. dia

dia 13

dia 14

A függvény leírása A függvények csak egy érték kiszámítására szolgálnak, 1. ezért az első különbség az, hogy az eljárásnak több paraméterhez is lehet új értéke, és a függvénynek csak egy van (az lesz az eredmény). 2. A második különbség a függvény fejlécében van. Ez a FUNCTION szóból áll, amelyet a függvény neve követ, majd zárójelben a formális paraméterek listája, majd a függvény eredményének típusa kettősponttal elválasztva. 3. A függvénytörzsnek tartalmaznia kell legalább egy hozzárendelési operátort, ahol a függvény neve a bal oldalon, az értéke pedig a jobb oldalon található. Funkció (): Leírás Kezdete Funkció törzse:=; vége;

dia 15

Számítsa ki az a:=(3n!+2m!)/(m+n) kifejezés értékét! program fn2; Használja a crt-t; Varm,n:integer; a:real; függvény tény(d:integer) :longint; var i:integer; q:longint; beginq:=1; ha i:=1-től d-ig q:=q*i; tény:=q; vége; start clrscr; writeln("adja meg az n, m értékeket"); readln(n,m); a:=(3*tény(n)+2*tény(m))/tény(m+n);; writeln("kifejezés értéke, ha m= ",m:4," és n= ",n:4,"egyenlő",a:8:3); readln; vége.

16. dia

Írj egy programot, amely megtalálja az ab-t, azaz b-edik fokozat A számok A, ahol A és B egész számok, és B>0, a billentyűzetről beírva. Írjon programot, a függvényt a pr2 eljárási programmal helyettesítve; Használja a crt-t; var a,b:integer; c:longint; Függvénylépések(x,y:integer):longint; var i:integer; s:longint; kezdődik s:=1; ha i:=1-től y-ig s:=s*x; István:=s; vége; start clrscr; writeln("adja meg az a, b értékeket"); readln(a,b); C:=lépés(a,b); writeln("s=",s); readln; vége.

dia 17

dia 18

A paraméterek függvényeknek és eljárásoknak való átadásának mechanizmusa Mit fog kinyomtatni az eljárás és mit a program? Globális változók Helyi változók a b 3 3 -3 Cím c a b c 48 Cím c A:=b+3 B:=3*a C:=a+b Állapot C 24 5 8 Válasz

dia 19