rutiner och funktioner. Rutiner och funktioner i Pascal

08.01.2022

Läs också

Kameratips för Samsung Galaxy S8 och S8 Plus

Samsung Galaxy J1 vs Samsung Galaxy J3 - jämförelse av två vanliga smartphones

För smartphones och surfplattor ser det ut så här

Firmware för smartphone Samsung GT-I9300 Galaxy S III Firmware för telefon samsung galaxy s3 gt i9300

Cyklisk omstart av Samsung Smartphone: Orsaker och lösningar

8: e klass. Programmering på ABC-språk Pascal

Informatiklärare, NIS, Uralsk FMN Zelenov Boris Alexandrovich

Eleverna använder procedurer och funktioner för att lösa problem
Eleverna lär sig att lösa stora problem genom att dela upp dem i mindre.

Att forma begreppet procedurer och funktioner i ett programmeringsspråk.

Eleverna känner till begreppen "procedurer" och "funktioner", bestämmer de formella och faktiska parametrarna

Förväntade resultat - Beskrivningar:

1.Känner till definitionen av "förfarande"

2.Känner till definitionen av "funktion"

3. Definierar de faktiska och formella parametrarna

4.Särskiljer parametervärden och variabler

5. Hittar ett anrop till en procedur eller funktion i programkoden

Elviras standardplan

1. Ta bort papper

2. Vattna blommorna

3. Tvätta skrivborden

4. Torka av glas

Slut på algoritm

Hur kan man förbättra organisationen av denna process?

Lektionens ämne

Rutiner:

Ishki bagdarlam

subrutin

Procedur

Parameter

Användbara fraser:

För att överföra värdena för variabler till proceduren (funktionen), används de faktiska parametrarna ...

För att beskriva proceduren bör man först ...., sedan ...

Konceptet med en subrutin

Definition

subrutinär en separat funktionellt oberoende del av programmet.

subrutiner

Förfaranden

eliminera behovet av att upprepade gånger upprepa liknande fragment i programmets text;
förbättra programmets struktur, vilket gör det lättare att förstå;
öka motståndet mot programmeringsfel och oförutsedda konsekvenser under programändringar.

Rita ett staket med hjälp av ett programmeringsspråk

I den här uppgiften kan du skapa en procedur som kommer att exekvera algoritmen för att rita ett fragment (staket), och sedan ständigt hänvisa till denna procedur och ändra pennans initiala position

Beskriv hur man rationellt ritar en julgran i en programmeringsmiljö

De är oberoende fragment av program, designade på ett speciellt sätt och med ett eget namn.

Samspel mellan huvudprogram och underprogram

blockdiagram

Subrutinanropsblockering (procedur eller funktion)

Subrutinnamn (procedur eller funktion)

blockdiagram

Beskrivningen av proceduren ser ut som:

procedur namn (lista över formella parametrar); beskrivningsavsnitt Börja operatörer slutet ;

Funktionsbeskrivningen ser ut så här:

fungera namn (lista över formella parametrar): returtyp;

beskrivningsavsnitt Börja operatörer slutet ;

Plats i programmet

program ...;

//Description section Uses, Const, Var, ...

procedur A ;

Börja ....... slutet ;

procedur B ;

Börja ........ slutet ;

Funktion C ;

Börja ........ slutet ;

//Huvudprogram

Börja ........ slutet .

Skillnaden mellan en funktion och en procedur är att resultatet av exekveringen av de operatorer som utgör funktionens kropp alltid är ett enda värde, så anropet till funktionen kan användas i motsvarande uttryck tillsammans med variabler och konstanter.

Förfaranden

Funktioner

Kan ha flera resultat eller utföra någon åtgärd

Den har bara ett resultat, vars typ anges separat när funktionen deklareras.

Resultaten kan vara vilken typ av arrayer som helst, strängar, siffror osv.

Resultatet kan bara vara ett reellt, heltals- eller char-värde.

Proceduranropskommandot är ett separat kommando som används oberoende.

Ett funktionsanrop kan endast användas som en komponent i ett uttryck av lämplig typ.

En funktions brödtext måste innehålla minst en tilldelningsoperator, till vänster om vilken funktionens namn anges.

b sedan max:=a annat max:=b; MaxNumber:= max; end;" width="640"

Procedur eller funktion?

MaxNumber(a,b: heltal): heltal;

var max: heltal;

MaxNumber:= max;

b sedan max:=a annat max:=b; end;" width="640"

Procedur eller funktion?

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

om ab då max:=a annat max:=b;

Procedur eller funktion?

ChangeColor(C1, C2: Word);

TextBackGround(C2)

Procedur eller funktion?

Add(X, Y: Heltal): Heltal;

Faktisk

Indikeras i huvudprogramsektionen

Formell

Anges i underprogrammet
Anges i underprogrammet

Ett proceduranrop görs av ett uttalande som har följande format:

procedurnamn (lista över faktiska parametrar);

Lista över faktiska parametrarär deras uppräkning separerad med kommatecken.

I språkstandarden Pascal kan parametrar skickas på två sätt - efter värde och genom referens. Parametrar som skickas av värde kallas värdeparametrar passerat genom referens - variabla parametrar. De senare kännetecknas av att de föregås av tjänsteordet var i rubriken för en procedur (funktion).

Passerar parametrar. Formella parametrar

Variabler

Värderingar

Parametrar efter värde

Formella parametrar

Variabler

Formella parametrar

Parametrar efter värde

I den första metoden (som passerar genom värde) kopieras värdena för de faktiska parametrarna till motsvarande formella parametrar.

Procedur

Namnprocedur (a, b: heltal);

Huvudprogram

Om dessa värden ändras under exekveringen av proceduren (funktionen), kan initialdata (faktiska parametrar) inte ändras

Var c, d: heltal;

När man passerar genom referens leder alla ändringar som sker i kroppen av en procedur (funktion) med formella parametrar till omedelbara liknande förändringar i de faktiska parametrarna som motsvarar dem.

Procedur

Namnprocedur (a, b: heltal, Var c: reell);

Huvudprogram

Ändringar sker i variablerna i det anropande blocket, så utdataparametrar skickas med referens. När de anropas kan de faktiska parametrarna som motsvarar dem bara vara variabler.

Du skriver:

1. Faktiska parametrar ___________

Procedur Kvad(R: real; var S: real);

2.Formella parametrar ___________

3. Formella parametrar-värden __________

5. Procedurnamn ___________

6. Anropa proceduren från programmet __________________

Interaktiv uppgift

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

Elvira är klassledare. Hon måste göra en plan för den allmänna städningen i klassrummet: ta bort pappren, vattna blommorna, tvätta skrivborden, torka av fönstren. Vilket är det bästa sättet för henne att organisera sitt arbete? Hjälp Elvira.

Elvira avancerad plan

Rutiner:

Arsen - tar bort papper

Mila vattnar blommor

Vitaly - tvättar skrivbord

Indira - torkar glas

1. Kör Arsen

2. Kör Mila

3. Kör Vitaly

4. Kör Indira

Slut på algoritm

Vilka nya strukturer av programmeringsspråket har vi mött idag?
Namnge de studerade parametrarna

Hur överförs parametrar till en procedur?

Lektionssammanfattning

Hitta definitioner: "Lokala variabler" och "Globala variabler"

Komponera två uppgifter där procedurer eller funktioner kan användas.

Hur skulle du definiera ämnet för lektionen? (sminka på ditt eget namn)
Vad tycker du att du ska lära dig i nästa lektion?

Låt oss träffas

nästa lektion!

Att tycka om förhandsvisning presentationer skapa ett konto ( konto) Google och logga in: https://accounts.google.com

Bildtexter:

Rutiner och funktioner i Pascal. Rekursion Utförd av läraren i datavetenskap GBOU skola 1362 Sanina Marina Sergeevna

Subrutin - en autonom del av programmet som utför en viss algoritm och tillåter åtkomst till den från olika delar allmänt program. Genom att använda subrutiner kan du implementera en av de mest moderna programmeringsmetoderna - strukturerad programmering.

subrutiner procedur funktion PROCEDUR FUNKTION

Procedurer och funktioner i Pascal deklareras i beskrivningsdelen bakom variabeldelen.

Funktioner och procedurer har parametrar (variabler som passerar ett värde). De är av två typer: 1) Formella - de som finns i beskrivningen av subrutinen 2) Faktiska - de som överförs från huvudprogrammet till en funktion eller procedur. De faktiska parametrarna måste matcha de formella i antal, ordning och typ.

Dessutom har subrutinen variabler. som hon kommer att fortsätta arbeta med. De är återigen uppdelade i två typer: 1) Globala variabler, det vill säga verkar i hela programmet 2) Lokala - de som endast verkar i en procedur eller funktion

Procedurer Används när en subrutin behöver få flera resultat. Det finns två typer av procedurer: med en parameter; utan parameter.

Procedurstrukturen liknar programstrukturen och består av en rubrik och ett block (procedurkropp). procedur ProcedureName; var … begin …//Procedur body end ; start // huvudprogramtext slut.

Procedurer utan parametrar procedur pr; var i: heltal ; börja för i:=1 till 60 skriv (‘ * "); skrivln ; slut . börja pr ; slut. Det här programmet matar ut en sträng med 60 asterisker.

Procedur med en parameter. Skriv ett program för att byta plats med två nummer c=5 och d=7 program obmenDan ; var c,d:heltal ; procedur obmen(a,b:heltal); var m:heltal; beginm:=a; a:=b; b:=m; skrivln(a,b); slutet; begin writeln("Ange 2 siffror: "); readln(c,d); obmen(c,d); writeln(c," ",d); slutet.

Analys av problemet 1) vid anrop av obmen-proceduren med två parametrar 5 och 7 placeras även siffrorna 5 och 7 i variablerna a respektive b: с 5 d 7 a 5 b 7

För att variablerna c och d , a och b ska hänvisa till samma minnesceller (om värdena för a och b ändras, kommer värdena på c , d också att ändras) när de formella parametrarna beskrivs, lägg till ordet VAR före de nödvändiga variablerna: procedure obmen (var a,b:heltal); c 5 d 7 a b

Funktioner Uppsättningen av inbyggda funktioner i Pascal är ganska bred (ABS, SQR, TRUNC, etc.). Om en ny, icke-standardiserad funktion ingår i programmet, måste den beskrivas i programtexten, varefter den kan nås från programmet. Anropet till funktionen utförs på höger sida om uppdragsoperatören, med angivande av funktionens namn och de faktiska parametrarna. En funktion kan ha sina egna lokala konstanter, typer, variabler, procedurer och funktioner. Beskrivningen av funktioner i Pascal liknar beskrivningen av procedurer.

Utmärkande egenskaper för funktioner: - exekveringsresultat - ett värde, som tilldelas funktionsnamnet och överförs till huvudprogrammet; - funktionsnamnet kan inkluderas i uttrycket som en operand.

Funktionsbeskrivning: function () : typ; (lokalt namnbeskrivningsavsnitt) Start (avsnitt med körbara satser) :=; ( nödvändig parameter ) End;

Funktionsanrop: := (); 1 . Till höger om uppdragsoperatören. 2. I ett uttryck i förgreningsoperatörens tillstånd. 3. I utmatningsproceduren, som ett resultat av funktionen.

Rekursion Procedurer och funktioner i Pascal kan kalla sig, d.v.s. har den rekursiva egenskapen. En rekursiv funktion måste nödvändigtvis innehålla ett rekursivt avslutningsvillkor för att inte få programmet att gå i loop. Varje rekursivt anrop skapar en ny uppsättning lokala variabler. Det vill säga variabler som ligger utanför den anropade funktionen ändras inte.

Komponera en rekursiv funktion som beräknar fakulteten för ett tal n enligt följande: n ! = 1 om n= 1 n!= (n -1)! n om n > 1

funktion f(n: heltal): heltal ; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f kallar sig) end ;

Uppgifter Ändra värdena för variablerna a, b, c så att de är ordnade i icke-minskande ordning (a ≤ b ≤ c). Givet n heltal. Hitta bland dem talet vars siffror har det högsta värdet.

Subrutiner Ofta i en uppgift vill man upprepa en viss sekvens av påståenden i olika delar av programmet. För att beskriva denna sekvens en gång, och tillämpa den många gånger, används subrutiner i programmeringsspråk. En subrutin är ett specialdesignat programblock för dess vidare återanvändning i huvudprogrammet.Användningen av subrutiner låter dig implementera en av de modernaste programmeringsmetoderna - strukturerad programmering.

Subrutiner löser tre viktiga uppgifter som i hög grad underlättar programmeringen: 1. eliminera behovet av att upprepade gånger upprepa liknande fragment i programtexten, d.v.s. minska programmets omfattning; 2. förbättra programmets struktur, vilket gör det lättare att förstå när man analyserar; 3.minska risken för fel, öka motståndet mot programmeringsfel och oförutsedda konsekvenser under modifiering.

Procedurer och funktioner Det finns två typer av subrutiner i Pascal: procedur (PROCEDUR) och funktion (FUNCTION). Procedurer och funktioner i Pascal deklareras i beskrivningsdelen bakom variabeldelen. Program Programnamn; VAR … // avsnitt i beskrivningen av variabler i huvudprogrammet; procedur ProcedureName; var … begin …//Procedure body end; start //huvudprogrammets huvuddel slut.

Procedurer Procedurer används när flera resultat ska erhållas i en subrutin. Det finns två typer av procedurer i Pascal: procedurer med parametrar och utan parametrar. En procedur anropas av procedurens namn, följt av faktiska parametrar. När en procedur anropas upprättas en en-till-en-överensstämmelse mellan de faktiska och formella parametrarna, sedan överförs kontrollen till proceduren. Efter att proceduren har utförts överförs kontrollen till nästa, efter proceduranropet, operatör för det anropande programmet.

Exempel 1: En procedur utan parametrar som skriver ut en sträng med 60 asterisker. förfarande pr; var i: heltal ; börja för i:=1 till 60 gör skriv(* "); skrivln; slut; börja pr; slut.

Exempel 2. Skriv ett program för att byta plats med två nummer c=5 och d=7 program obmenDan; var c,d:heltal; procedur obmen(a,b:heltal); var m:heltal; beginm:=a; a:=b; b:=m; skrivln(a,b); slutet; begin writeln("Ange 2 siffror: "); readln(c,d); ändra (c, d); writeln(c," ",d); slutet. c5 d 7 a 5 b 7 a 7 b 5 3) men uppgifterna i variablerna c och d har inte ändrats, de finns i andra minnesceller

För att variablerna c och d, a och b ska hänvisa till samma minnesceller (om värdena på a och b ändras, kommer värdena på c och d också att ändras) när de formella parametrarna beskrivs, lägg till ordet VAR före de nödvändiga variablerna: procedure obmen (var a,b:heltal); c5 d 7 a b

Exempel 3. Givet 3 olika arrayer av heltal (storleken på var och en överstiger inte 15). I varje matris, hitta summan av elementen och det aritmetiska medelvärdet. program proc; var i, n, summa: heltal; sr: verklig; procedurarbete (r:integer; var s:integer; var s1:real); var mas: array av heltal ; j: heltal börjar s:=0; för j:=1 till r börjar läsa(mas[j]); s:=s+mas[j]; slutet; sl:=s/r; slutet;

(huvudprogram) börja för i:=1 till 3, börja skriva ("Vvedite razmer ",i, " masiva: "); readln(n); arbete(n, summa, sr); (anropsarbete) writeln("Summa elementov = ",summa); writeln("Srednearifmeticheskoe = ",sr:4:1); slutet; slutet.

Resultatet av programmets arbete: Programmet anropar arbetsproceduren tre gånger, där de formella variablerna r, s, s1 ersätts med faktiska n, summa, sr. Proceduren utför inmatning av arrayelement, beräknar summan och medelvärdet. Variablerna s och s1 återgår till huvudprogrammet, därför, före deras beskrivning, placeras tjänsteordet var. De lokala parametrarna mas, j är endast giltiga i proceduren. Global - i, n, summa, sr är tillgängliga genom hela programmet.

Funktioner i Pascal Uppsättningen av inbyggda funktioner i Pascal är ganska bred (ABS, SQR, TRUNC, etc.). Om en ny, icke-standardiserad funktion ingår i programmet, måste den beskrivas i programtexten, varefter den kan nås från programmet. Anropet till funktionen utförs på höger sida om uppdragsoperatören, med angivande av funktionens namn och de faktiska parametrarna. En funktion kan ha sina egna lokala konstanter, typer, variabler, procedurer och funktioner. Beskrivningen av funktioner i Pascal liknar beskrivningen av procedurer.

Exempel 4. Skriv en subrutinfunktion av grad a x, där a, x är valfria tal. Låt oss använda formeln: a x = e x l i ett program p2; var f, b, s, t, c, d: verklig; ( globala variabler) funktion stp (a, x: real) : real; variera: verklig; (lokala variabler) börjar y:= exp (x * ln (a)) ; stp:= y;(tilldelar funktionsnamnet för subrutinberäkningsresultatet) end; (funktionsbeskrivning avslutad) start d:= stp(2.4, 5); (beräkningskrafter för olika tal och variabler) writeln (d, stp (5,3.5)); läs (f, b, s, t); c:= stp(f, s)+stp(b, t); skrivln(c); slutet.

Funktioner En subrutin är en del av ett program utformat som en separat syntaktisk konstruktion och försedd med ett namn (ett oberoende programblock) för att lösa enskilda uppgifter. Procedurbeskrivning: procedur () (lokalt namnexekveringsavsnitt) Börja (uttalandeexekveringsavsnitt) Slut; Funktionsbeskrivning: funktion (): typ; (lokal namndeklaration avsnitt) Börja (körbar sats avsnitt) := ; (obligatorisk parameter) Slut; Proceduranrop: (); Funktionsanrop: := (); 1. På höger sida om uppdragsoperatören. 2. I ett uttryck i förgreningsoperatörens tillstånd. 3. I utmatningsproceduren, som ett resultat av funktionen. Beskrivning av subrutiner Procedurer

1 funktion f(n: heltal): heltal; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f kallar sig själv" title="Exempel 5. Komponera en rekursiv funktion som beräknar faktorialen för ett tal n enligt följande: n! = 1 om n= 1 n!= (n -1)! n om n > 1 funktion f (n: heltal): heltal; börja om n = 1 så f:= 1 annars f:= n * f (n -1); (funktion f kallar sig själv" class="link_thumb"> 19 !} Exempel 5. Skriv en rekursiv funktion som beräknar faktorialen för ett tal n enligt följande: n! = 1 om n= 1 n!= (n -1)! n om n > 1 funktion f (n: heltal): heltal; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f kallar sig själv) end; 1 funktion f(n: heltal): heltal; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f kallar sig"> 1 funktion f (n: heltal): heltal; börja om n = 1 så f:= 1 annars f:= n * f (n -1); (funktion f anropar sig själv) slut; " > 1 funktion f (n: heltal): heltal; börja om n = 1 så f:= 1 annars f:= n * f (n -1); (funktion f kallar sig" title="Exempel 5) Skriv en rekursiv funktion som beräknar faktorn för n enligt följande: n!=1 om n= 1 n!= (n -1)!n om n > 1 funktion f (n: heltal): heltal;börja om n = 1 sedan f:= 1 annars f:= n * f (n -1); (funktion f kallar sig själv"> title="Exempel 5. Skriv en rekursiv funktion som beräknar faktorialen för ett tal n enligt följande: n! = 1 om n= 1 n!= (n -1)! n om n > 1 funktion f (n: heltal): heltal; börja om n = 1 då f:= 1 annars f:= n * f (n -1); (funktion f anropar sig själv"> !}

subrutiner V TurboPascal

subrutin – är en namngiven, logiskt komplett grupp av kommandon som kan anropas för att utföras hur många gånger som helst från olika platser program.

Anledningar till att använda subrutiner

förenkla utvecklingen av stora program genom att dela upp (dela upp) uppgiften i flera deluppgifter;
ökad synlighet av programmet;
sparar minne.

Typer av underprogram

förfaranden

funktioner

Procedurär en oberoende namngiven del av programmet utformad för att utföra specifika åtgärder.

Procedurer utan parametrar

Inspelningsformat :

procedur ;

slutet ;

Alla variabler som används i procedurer utan parametrar beskrivs i huvudprogrammet (i Var-modulen).

Exempel . Skriv ett program för att hitta volymen på en cylinder.

programcylinder;

Var R, H, V: verklig;

Inmatningsförfarande ; (datainmatningsförfarande)

Writeln('Ange radievärdet');

writeln('Ange höjdvärde');

procedur; { procedur beräkningar volym }

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

Output Procedur ; ( output procedur )

writeln('V=',V);

Förfaranden c parametrar

Procedurer kan beskriva konstanter, variabler och andra procedurer.
Beskrivningsdelen i procedurer har samma struktur som i huvudprogrammet.
Lokala variablerär variabler som deklareras inom en procedur.
Lokala variabler är inte tillgängliga utanför en procedur.
Ändringar av lokala variabler inom en procedur påverkar inte värdena för variabler med samma namn men som deklareras utanför proceduren.

Förfaranden c parametrar

Globala variabler

Exempel .

programuppgift;

Var a, b: heltal;

förfarande lokal;

Var a, x: char; För förfaranden lokal:

Börja variabel x - lokal variabel

a:='! '; (programmet kan inte ändra sitt värde)

b:=b+1; variabel b - global variabel

slutet ; (alla ändringar av värdet på denna variabel i proceduren

BEGIN behålls även efter att ha avslutat proceduren)

b:=100; variabel a i huvudprogrammet – hel typ,

lokal; och i proceduren - teckentyp. variabel a

writeln('a=', a); heltalstyp är inte tillgänglig i den lokala proceduren.

writeln('b=',b);

Resultatet av programexekveringen: a=0; b=101.

); Start; slutet ; "width="640"

Överför parametrar till Turbo Pascal

1. Skicka parametrar efter värde

Värdeparametrar – variabler deklarerade efter procedurens namn i parentes. Före dem finns inget serviceord Var .
Inspelningsformat :

procedur (:

variabel);

slutet ;

formella parametrar .
faktiska parametrar .

Exempel .

programparameter;

Var m, n: heltal;

summa Procedur(a, b: heltal);

writeln('S=',S);

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

Variabler a Och b är formella parametrar och variabler m Och n - faktisk. Faktiska parametervärden m =100 och n =10 skickas till formella parametrar a Och b .

Ändringar av faktiska parametrar sker endast inom proceduren och påverkar dem inte utanför proceduren.

; var variabel:); Start; slutet ; "width="640"

Överför parametrar till Turbo Pascal

2. Skicka parametrar efter namn

Variabla parametrar – variabler deklarerade efter procedurens namn inom parentes och föregås av tjänsteordet Var .
Inspelningsformat :

procedur (:

variabel; Var

variabel:);

slutet ;

b sedan min:= b; om min c då min:= c; slutet ; BEGIN writeln('Ange tre siffror'); readln(al, bl, cl); writeln ('skriv in tre siffror'); readln(a2,b2,c2); minimum(al,bl,cl, minl); minimum(a2,b2,c2, min2); S:= minl + min2; writeln('S=', S); SLUTET. Exempel. Givet två tripletter av tal: a 1, b 1, c 1 och a 2, b 2, c 2. Hitta värdet på summan: S=min (a1, b1, c1) + min (a2, b2, c2) "width=" 640"

Var al,bl,cl,a2,b2,c2, min1, min2, S: reell;

Procedurminimum (a,b,c: real; Var min: real);

om min b då min:= b;

om min c då min:= c;

writeln('Ange tre siffror');

readln(al, bl, cl);

writeln ('skriv in tre siffror');

readln(a2,b2,c2);

minimum(al,bl,cl, minl);

minimum(a2,b2,c2, min2);

S:= minl + min2;

writeln('S=', S);

Exempel. Givet två tripletter av tal: a 1, b 1, c 1 och a 2, b 2, c 2. Hitta värdet på summan: S=min (a1, b1, c1) + min (a2, b2, c2)

Fungeraär en subrutin vars resultat är något värde.

Inspelningsformat :

fungera (:

slutet ;

I funktionskroppen måste funktionsnamnet tilldelas resultatet av dess exekvering.
När en funktion anropas måste dess namn med en lista över faktiska parametrar inkluderas i uttrycket som en operand.

programuttryck;

funktionsmodul (a: real) : real;

writeln('Ange värdet på variabeln');

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

writeln ('y=', y);

Exempel . Beräkna värdet på uttrycket: y = | x -3 | + | x+6 |

glida 1

glida 3

Subrutiner: Globala och lokala variabler Alla subrutiner måste deklareras i en deklarationssektion. Varje subrutin måste ha ett namn. Information mellan huvudprogrammet och subrutinerna överförs av globala parametrar (variabler) som är giltiga i någon del av programmet och har det namn som beskrivs i huvudprogrammet. Inuti subrutinen kan lokala parametrar (variabler) användas - deras namn och värden är meningsfulla endast inom gränserna för den givna subrutinen och är inte tillgängliga för det anropande programmet

glida 4

Formella och faktiska parametrar I beskrivningen av underprogram anges parametrar endast med namn, därför kallas de formella. Tills subrutinen anropas har de ingen mening. De reserverar endast utrymme för de faktiska parametrarna och bestämmer deras antal och datatyp. Faktiska parametertyper: Värdeparametrar anger vilket värde som ska tilldelas en viss subrutinparameter. Efter att subrutinen slutar återgår de till sina tidigare värden, även om de ändrades i subrutinen. De variabla parametrarna i subrutinen ersätter de formella, de kan ändra sitt värde under exekveringen av subrutinen och spara ändringarna när subrutinen avslutas (variabelparametrar föregås av nyckelord Var).

glida 5

glida 6

Beskrivning av proceduren Program Pr1; Const...Type...Var...Procedur(); Beskrivning Start Procedur body End; Börja ... (); …slutet. När proceduren anropas ersätts de formella parametrarna med de faktiska.

Bild 7

Proceduren för att beräkna summan av två tal program pr1; Använd crt; Var a,b,s:real; procedur summa(x,y:real;var z:real); beginz:=x+y; slutet; börja clrscr; writeln("Ange a,b"); readln(a,b); summa(a, b, s); writeln(" summa av siffror ",a:3:1," och ",b:3:1," = ",s:3:1); readln; slutet. x,y,z – formella parametrar, lokal variabler a,b,s– globala variabler a,b,s – faktiska parametrar x y z a b s Parameter-värden Parameter-variabel

Bild 8

Bild 9

glida 10

Beräkna värdet på uttrycket a:=(3n!+2m!)/(m+n)! Vilken typ av variabler ska användas för att hitta faktorialen? programpr2; Använd crt; Varm,n,x,y,z:heltal; a:real; procedurfakta(d:heltal;var q:heltal); var i:integer; beginq:=1; för i:=1 till d gör q:=q*i; slutet; börja clrscr; writeln("skriv in värdena n, m"); readln(n,m); faktum(n, x); fakta(m,y); faktum(m+n,z); a:=(3*x+2*y)/z; writeln("uttryckets värde när m= ",m:4," och n= ",n:4,"lika med",a:8:3); readln; slutet. N!=1 2 3… N

glida 11

Inmatning av element i en endimensionell matris Funktionen Random(X) genererar ett slumpmässigt tal från 0 till X av heltal eller reell typ (innan funktionen anropas måste den initieras med hjälp av Randomize-proceduren). Om X inte anges kommer resultatet att vara av typen Real mellan 0,0 och 1,0. För att få en array med heltals slumptal från intervallet slumpmässigt(B-A+1)+A Uppgift: Ordna inmatningen av element i en endimensionell array med hjälp av en slumptalsgenerator (värdeintervall från -10 till 20) och utmatning av element som en procedur. För A=-10 B=20 slumpmässigt(20-(-10)+1)+(-10)

glida 12

glida 13

glida 14

Beskrivning av funktionen Funktioner är utformade för att bara beräkna ett värde, 1. därför är dess första skillnad att proceduren kan ha nya värden för flera parametrar, och funktionen har bara en (det kommer att bli resultatet). 2. Den andra skillnaden är funktionshuvudet. Den består av ordet FUNCTION följt av namnet på funktionen, följt av en lista med formella parametrar inom parentes, följt av typen av funktionsresultat separerat med ett kolon. 3. Funktionskroppen måste innehålla minst en tilldelningsoperator, där funktionsnamnet är på vänster sida och dess värde på höger sida. Funktion (): Beskrivning Start Funktion body:=; slutet;

glida 15

Beräkna värdet på uttrycket a:=(3n!+2m!)/(m+n)! program fn2; Använd crt; Varm,n:heltal; a:real; funktionsfakta(d:heltal) :longint; var i:integer; q:longint; beginq:=1; för i:=1 till d gör q:=q*i; faktum:=q; slutet; börja clrscr; writeln("skriv in värdena n, m"); readln(n,m); a:=(3*fakta(n)+2*fakta(m))/fakta(m+n);; writeln("uttryckets värde när m= ",m:4," och n= ",n:4,"lika med",a:8:3); readln; slutet.

glida 16

Skriv ett program som ska hitta ab, alltså b-te graden siffrorna A, där A och B är heltal och B>0, inmatade från tangentbordet. Skriv ett program, ersätt funktionen med procedurprogrammet pr2; Använd crt; var a,b:heltal; c:longint; Funktionssteg(x,y:heltal):longint; var i:integer; s:longint; börjar s:=1; för i:=1 till y gör s:=s*x; Stephen:=s; slutet; börja clrscr; writeln("ange värden a, b"); readln(a,b); C:=steg(a,b); writeln("s=",s); readln; slutet.

glida 17

glida 18

Mekanism för att överföra parametrar till funktioner och procedurer Vad kommer att skrivas ut av proceduren och vad av programmet? Globala variabler Lokala variabler a b 3 3 -3 Adress c a b c 48 Adress c A:=b+3 B:=3*a C:=a+b Tillstånd C 24 5 8 Svar

bild 19