Rutiner och funktioner i Pascal. Rekursion. Subrutiner Ofta i en uppgift vill man upprepa en viss sekvens av påståenden i olika delar av programmet. Rutiner och funktioner i Pascal presentation för lektionen om informatik och IKT (betyg 11) på ämne III. HANDLA OM

Lämna en kommentar 6,950

Rekursion i Pascal Lärare: Tlekhurai Yu.V. MOU "Lyceum nr 8" Vad ser du på bilderna? Detta fenomen i konsten kallas rekursion "För att förstå rekursion måste du först förstå rekursion." rekursion - partiell definition av ett objekt genom sig självt, definition av ett objekt med hjälp av tidigare definierade. Vetenskapligt sett: rekursion - en metod för att definiera en klass av objekt eller metoder genom att preliminärt specificera ett eller flera (vanligtvis enkla) basfall eller metoder för den, och sedan specificera, på grundval av dessa, reglerna för att konstruera den klass som definieras. Peter Deutsch Peter Deutsch

Iteration från människa.

Rekursion kommer från Gud.

Rekursion i fysik Rekursion i språk och litteratur Ett klassiskt exempel på oändlig rekursion är två speglar placerade mitt emot varandra: två korridorer av blekande reflektioner av speglar bildas i dem. Ett annat exempel på oändlig rekursion är självexciteringseffekt (positiv återkoppling) i elektroniska förstärkningskretsar, när signalen från utgången träffar ingången, förstärks, träffar kretsens ingång igen och förstärks igen. Förstärkare för vilka detta driftsätt är standard kallas självoscillatorer. Ett exempel på en rekursiv ordbokspost: "Prästen hade en hund ..." - en typisk rekursion Flera berättelser av Stanislav Lem ägnas åt incidenter med oändlig rekursion: En berättelse om gravar ("The Star Diaries of John the Quiet") , där hjälten successivt går från en artikel om sepulkar till en artikel om sepulcaria , därifrån till artikeln om sepulcaria, där det återigen finns en referens till artikeln "sepulcaria". En berättelse om en intelligent maskin som var smart nog och lat nog att bygga en liknande för att lösa uppgiften och anförtro lösningen till den (resultatet blev en oändlig rekursion, när varje ny maskin byggde sin egen liknande och överförde uppgiften till den). Rekursion i programmering är ett sätt att organisera en beräkningsprocess där en procedur eller funktion refererar till sig själv under exekveringen av dess konstituerande uttalanden. För att ett sådant samtal inte ska vara oändligt, måste texten i subrutinen innehålla ett villkor när det nås som inget ytterligare samtal inträffar. sålunda kan ett rekursivt samtal endast inkluderas i en av subrutinens grenar. Exempel. Beräkna faktorialet för ett naturligt tal Komponera en rekursiv funktion som beräknar faktorialet för ett tal n enligt följande: funktion f (n: heltal): longint; börja om n = 1 då f:= 1 annars f:= n * f(n -1); (funktion f kallar sig själv) avsluta Pascal-programmet med rekursion: Var n: heltal; a:longint; function factorial(n: heltal): longint; börja om n = 1 då faktoriell:= 1 annars faktoriell:= n * faktoriell (n -1); slutet; Börja skriva('n='); readln(n); A:=faktoriell(n); Write('n!=',a); readln; slutet. Leonardo Pisan Fibonacci

Fibonacci-tal är delar av en numerisk sekvens

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ..., där varje efterföljande tal är lika med summan av de två föregående.

Uppgift: Visa en serie Fibonacci-tal på skärmen, bestående av n element. Beskrivning av variabler: n är antalet element i raden; a, b är värdena för de två sista elementen i serien; c är en buffert ("reserv") variabel; jag - kontra. Algoritm för att lösa problemet: 1. Få värdet på n. 2. Tilldela a och b värdena 0 respektive 1 (detta är de första siffrorna i Fibonacci-serien). Ta med dem till skärmen. 3. Börja från det 3:e elementet till n: a) visa summan av a och b, b) lagra värdet av variabeln b i c, c) skriv summan av a och b till b, d) tilldela värdet av c till a. Pascal-program som använder iteration: programmet Fibonacci; var a,b,c,i,n: heltal; Börja skriv("n = "); readln(n); a:=0; Skriv en," "); b:= 1; skriv(b," "); för i:=3 till n börjar skriv(a+b," "); c:=b; b:= a + b; a:=c; slutet; readln; slutet. Pascal-program som använder rekursion: Den rekursiva definitionen för beräkning av Fibonacci-tal är följande: Denna definition av Fibonacci-tal kan enkelt omvandlas till en rekursiv funktion: funktion f(n: Heltal): longint; börja om n<= 1 Then f:= n else f:= f(n– 1) + f(n - 2); end; Program chislaFibonacci; var n,i: integer; a: longint; function fib (n: integer): longint; begin If n <= 1 Then fib:= n else fib:= fib(n– 1) + fib(n - 2); End; begin write(‘n=’); readln(n); for i:=0 to n do begin A:= fib (n); write (‘ ’,a); end; readln; end. Домашнее задание Написать программу нахождения НОД двух натуральных чисел, используя алгоритм Евклида и рекурсию Даны два натуральных числа men Och b. Om men= b, sedan nod( men,b)=a. Om men>b, sedan nod( men,b)= nod ( a -b,b). Om men< b, sedan nod( men,b)= nod ( men,b-a). Program noddvyxchisel; var a,b: longint; function nod(a,b:longint): longint; börja Om a = b Då nicka:= a annat om a>b då nicka:= nicka(a-b,b) annars nicka:= nicka(a,b-a) Slut; börja skriva('a='); readln(a); skriv('b='); readln(b); A:=nicka(a,b); write('nod=',a); readln; slutet. Torn i Hanoi problem. I det här fallet måste följande regler följas strikt:

Endast en skiva kan flyttas åt gången;
en större skiva kan inte placeras på en mindre skiva;
den borttagna skivan måste sättas på valfri dragskiva innan en annan skiva tas bort.

En av de tre diamantspirorna har 64 runda guldskivor. Skivorna har olika radier och är placerade på spiran i fallande radieordning från bas till topp. Det är nödvändigt att överföra skivorna från den första spiran till den andra, använda den tredje spiran om det behövs.

En uppgift. Skriv ett rekursivt program som löser Hanois tornproblem ovan med n skivor (n = 1, 2, …). Lösning. Ange namnen på spirorna: a, b, c. Låt vara hanoi(n,a,b,c)är den önskade funktionen som returnerar sekvensen av förskjutningar av skivor med a på b använder sig av c enligt ovanstående regler. För n=1 kan vi lösa problemet. Du behöver bara utföra operationen "move a på b". Låt oss anta att vi kan lösa detta problem för n - 1 diskar. Låt oss flytta n-1-skivor med a på från. Flytta sedan den återstående enheten från a på b och slutligen flytta n-1-skivor med c på b. Indata: antal skivor på pinne a; Produktion: sekvensering; Steg0: (definierar typen av variabler); Steg 1: (beskrivning av hanoi-proceduren som utmatar en sekvens av åtgärder); Steg 1.1: (flytta (n-1) skivor från pinne a till pinne b); Steg 1.2: (flytta n:e skivan från a till c); Steg 1.3: (flytta (n-1) skiva från b till c); (steg 1.2-1.3 utförs rekursivt); Steg 2:(huvudprogram); Steg 2.1: (ange antalet diskar); Steg 2.2: (anropar hanoi-proceduren). Problemlösning i Pascal Program bahnya; varn: heltal; a,b,c: char; procedur hanoi(n: heltal;a,b,c: char); börja om n>0 börjar då hanoi(n-1,a,c,b); writeln ("Peremestit disk so sterzhnya ",a," na sterzhen" ",b); hanoi(n-1,c,b,a); slut; slut; Börja skriva ("Vvedite naturalnoe chislo n"); readln ( n); a:="a"; b:="b"; c:="c"; hanoi (n,a,c,b); readln; end. Läxor Skriv ett program för att beräkna graden med naturlig exponent Givet: gradbas X Exponent till Om k=0, då grad(k,x)=1, Annars grad(k,x)=x grad(k-1,x) Program stepen; variera: verklig; n: heltal funktionssteg(k:heltal, x:real): verklig; börja Om k = 0 Sedan steg:= 1 annat steg:= x * steg(k-1,x) Slut; begin write('vvedite foundation stepeni x='); readln(y); write('vvedite pokazatel stepeni k='); readln(n); skriv('x v stepeni k=', steg(n, y)); readln; slutet. Självständigt arbete

Hitta summan av siffrorna i ett tal
Bestäm om ett givet naturligt tal är primtal
Hitta den första siffran i ett nummer
Konvertera naturligt tal från decimal s.s. till binär
Hitta summan av elementen i en heltalsmatris med 20 element
Byt ut värdena för två heltal
Beställ värdena för tre variabler a, b, c i stigande ordning
Hitta antalet siffror i ett naturligt tal n
Hitta det största av tre givna tal
Hitta antalet positiva tal bland fyra A, B, C, D

Självstudiesvar #2 Enkelt program; var n, m, s: heltal; funktion prost(m, n:heltal): boolean; börja Om n = m Då prost:= true else prost:= (n mod m<>0) och enkel (m+1, n); slutet; börja skriva('n='); readln(n); M:=2; Om prost(m,n) så skriv (n,'prostoechislo') Annars skriv (n,'komposition'); readln; slutet.

programöversättning;

procedure dvd(n:longint);

Om n >1 Då dvd(n div 2);

skriv(n mod 2);

Syftet med lektionen

pedagogisk

att hos eleverna bilda ett enhetligt system av begrepp relaterade till begreppen procedur och funktion;
lära dig hur du använder subrutiner för att lösa problem i Pascal, samt lära dig att förstå vilken typ av subrutin som behövs när du löser ett specifikt problem;
visa de grundläggande teknikerna för att använda subrutiner;

pedagogisk

att odla noggrannhet, uppmärksamhet, organisation;
kultur av datorkunskaper;

utvecklande

utveckla logiskt tänkande, algoritmisk kultur hos elever;
utveckla kunskaper och färdigheter för att skriva och felsöka subrutiner i Pascal.

Studenter måste:

känna till reglerna för att skriva procedurer utan parametrar och med parametrar;
känna till reglerna för inspelning av funktioner;
kunna tillämpa procedurer och funktioner för att lösa enkla problem.

Under lektionerna

I. Org. ögonblick

II. Introduktion. Relevans

Ge en uppgift på arken ( Bilaga 1 ). Hitta upprepningar.

Ibland på olika platser i programmet är det nödvändigt att utföra nästan samma sekvens av åtgärder med olika initiala data. Sådana handlingssekvenser kan formaliseras i form av sk subrutiner (från engelska, subrutin) - gruppera uttalanden i ett block som kan refereras till med namn, och mer än en gång.

Subrutiner minskar programmets text, minskar avsevärt tiden för deras exekvering, gör livet lättare för programmerare som kan skapa program på ett modulärt sätt, det vill säga genom att sätta ihop ett komplext program från färdiga delar av enklare komponenter. Detta gör att en grupp programmerare kan skapa stora program och en grupp skolbarn att utveckla och implementera alla globala projekt.

Subrutiner är indelade i procedurer och funktioner.

Inbyggda (standard) procedurer och funktioner finns del språk och kan kallas vid namn utan föregående beskrivning. Till exempel , abs, sqrt, ln, sin... är funktioner (retur ett resultat), readln, write... är procedurer (returnerar inte ett resultat). Deras närvaro underlättar i hög grad utvecklingen av applikationsprogram. Men i de flesta fall några specifika för ett givet program hittar åtgärder inte direkta analoger i Turbo Pascal-bibliotek, och sedan måste programmeraren utveckla sin egen icke-standard rutiner och funktioner.

III. Förklaring av nytt material

Användarprocedurer är skrivna av oss själva programmerare i enlighet med syntaxen för språket i avsnitt för subrutinbeskrivning.

Procedurens struktur upprepar programmets struktur, det är ett "program i miniatyr" - det representeras också av en rubrik och en kropp.

Rubriken består av den reserverade ordproceduren, identifieraren (namn) förfaranden.

VAR ... // avsnitt i deklarationen av variabler i huvudprogrammet

procedur ProcedureName;

//huvuddelen av programmet

Anropa en procedur för efterföljande utförande skrivs i huvudprogrammets brödtext.

Exempel 1 Program för att beräkna area och omkrets.

Fördelar med subrutiner:

Program skrivna med subrutiner lättare att testa och felsöka, de har tydligare logisk struktur.
Den fristående karaktären hos underprogram gör det möjligt att anförtro deras sammanställning till olika programmerare. Så går uppdelningen av programmeringsarbetet till och därmed påskyndas dess slutförande;
Att använda subrutiner sparar minne. Minne för lagring av variabler som används i en subrutin tilldelas endast under dess exekvering och frigörs så snart dess exekvering avslutas.

Exempel 2 Användaren matar in två sidor av tre rektanglar. Ta fram deras område.

Du kan lösa problemet så här:

för i:=1 till 3 do

writeln('Ange a och b:');

writeln('Area=',a*b);

Det anses vara bra programmeringsstil att använda procedurer. Vi behöver en procedur som beräknar arean av en rektangel. Så här kommer huvudprogrammet att se ut schematiskt:

beräkning

Textproceduren finns redan där (se exempel 1). Låt oss skapa en andra procedur som beräknar arean. Men för att kunna räkna ut S måste du känna till 2 sidor, så proceduren måste visa vilka sidor den ska multiplicera.

procedur pl(c,d: heltal);

writeln('area av en rektangel med sidor',c, '',d, '=',S);

En parameter är en variabel som tilldelas ett värde. Existera formella parametrar definieras i rubriken för subrutinen, och faktiska parametrar – uttryck som anger specifika värden vid åtkomst till en subrutin.

Proceduren kommer att utföras om du kallar den vid namn och anger de faktiska parametrarna , separerade från varandra med kommatecken och inom parentes:

De faktiska parametrarna måste överensstämma i typ och kvantitet med de formella.

Så huvudprogrammet är:

för i:=1 till 3 do

Kommentar. När du löser detta problem är det nödvändigt att kontrollera siffrorna som angetts av användaren (de får inte vara negativa, annars kommer programmet att avbrytas).

Låt oss skapa ett verifieringsförfarande:

procedurfel(f,g:heltal);

om (f<0) or (g<0) then begin

writeln('rektangelsidor kan inte vara negativa');

stanna; // programavbrott

Slutligt program - Bilaga 4

Så formatet för proceduren är:

procedur<имя>(formella parametrar);

<операторы>;

Exempel 3 Skriv ett program för att byta plats med två nummer c=5 och d=7.

program utbyteDan;

var c,d:heltal;

procedur obmen(a,b:heltal);

m:=a; a:=b; b:=m;

writeln("Ange 2 siffror: ");

writeln(c," ",d);

Efter start av programmet kan man se att de formella parametrarna (i proceduren) har bytt plats, men de faktiska (som används i huvudprogrammet) har inte ändrats. Tänk på bilden, som visar en del av RAM:et:

1) när obmen-proceduren anropas med två parametrar 5 och 7, placeras siffrorna 5 och 7 också i variablerna a respektive b:

3) men i variablerna c och d har data inte ändrats, eftersom de finns på andra minnesplatser.

För variablerna c och d, a och b hänvisade till samma minnesceller (om värdena för a och b ändras, kommer värdena för c, d också att ändras) när du beskriver de formella parametrarna, lägg till ordet VAR före de nödvändiga variablerna:

procedur obmen (var a,b:heltal);

Ändra obmenDan-programmet:

Fel på grund av var. Tal är konstanter som inte kan ändras i en procedur.

Exempel 4 Hitta arean av en cirkel med en procedur som bara utför en beräkning men inte visar resultatet på skärmen.

procedurcirkel(r:real);

Proceduren bör returnera resultatet:

procedurcirkel (r:real; var S:real);

readln(a, e);

Kommentar: Variabeln i proceduren S används för att returnera resultatet av proceduren till huvudprogrammet. När den ändras ändras även den faktiska parametern i det anropande programmet, d.v.s. variabel e.

Oftare, för detta, i Pascal, istället för procedurer, använder de funktioner (subrutiner som returnerar något).

Funktionen liknar proceduren, men det finns två skillnader.

Funktionen överför resultatet av sitt arbete till programmet - det enda värdet vars bärare är namnet på dess funktion.
Funktionsnamnet kan inkluderas i uttrycket som en operand. Funktionen returnerar resultatet vid anropspunkten.

Till exempel kommer sqr(x) att kvadrera värdet på x och returnera det beräknade värdet på kvadraten av talet x till anropspunkten: y:=sqr(x);

En användardefinierad funktion består av en rubrik och en funktionskropp. En funktions kropp liknar ett programs struktur. Beskrivning av etiketter, konstanter, typer osv. giltig endast inom detta förfarande.

fungera<имя>(formella parametrar):<тип результата>;

<операторы>;

Sektionen måste innehålla minst en sats som tilldelar ett värde till funktionsnamnet. Resultatet av det senaste uppdraget returneras till larmcentralen.

Exempel 5 Låt oss skriva om problemet med arean av en cirkel.

funktion cirkel(r:real): verklig;

a:=cirkel(5); (MÅSTE tilldela)

Exempel 6 Hitta 1!+2!+…+n!

Vi använder funktionen att hitta faktorn, eftersom vi matar in den som en ingång och får resultatet.

function fact(a:heltal): heltal;

för i:=1 till en do

I raden fakta:=faktum*I;

kompilatorn hittar ett fel eftersom fakta måste anropas med parametrar. Därför introduceras vanligtvis en extra variabel i vilken resultatet placeras. Och sedan tilldelas detta resultat till faktavariabeln:

programfaktoriell;

varsum,n,j: heltal;

function fact(a:heltal): heltal;

var i,d: heltal;

för i:=1 till en do

för j:=1 till n do

summa:=summa+fakta(j);

IV. Lektionssammanfattning

Vid denna tidpunkt håller programmeringsprocessen på att bli industriell produktion av program baserad programmeringsteknik. Det är de flesta experter av åsikten top-down metod för mjukvarudesign mest lämpad för att lösa komplexa problem. Först definieras uppgiften i allmänna termer, sedan sker en gradvis förfining av dess struktur. I nästa steg delas varje deluppgift i sin tur upp i ett antal andra. Lösningen av ett separat fragment av ett komplext problem är ett oberoende programblock - en subrutin.

V. Läxor

Lös problem (skriftligt):

Skriv en procedur som ersätter alla bokstäver a med * i inmatningssträngen.
Två förslag ges. Hitta det totala antalet bokstäver "n" i dem. (Definiera en funktion för att beräkna antalet "n" bokstäver i en mening.)

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 denna subrutin 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. Variabelparametrarna i subrutinen ersätter de formella, kan ändra sitt värde under exekveringen av subrutinen och spara ändringarna när subrutinen avslutas (nyckelordet Var står framför variabelparametrarna).

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, lokala variabler a,b,s – globala variabler a,b,s – faktiska parametrar x y z a b s Parametervärden Parametervariabel

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); fakta(n, x); faktum(m,y); faktum(m+n,z); a:=(3*x+2*y)/z; writeln("värde av uttryck 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 array 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ärdeområde från -10 till 20) och utmatning element som procedurer. 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 beräkna endast 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 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 resultatet av funktionen, separerade 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; function fact(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("värde av uttryck när m= ",m:4," och n= ",n:4,"lika med",a:8:3); readln; slutet.

glida 16

Skriv ett program som kommer att hitta ab, det vill säga den b:te potensen av talet A, där A och B är heltal och B>0, inmatat 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

subrutiner i TurboPascal

subrutin – det är en namngiven logiskt komplett grupp av kommandon som kan anropas för exekvering hur många gånger som helst från olika platser i programmet.

Anledningar till att använda subrutiner

förenkla utvecklingen av stora program genom att dela upp (dela upp) uppgiften i flera deluppgifter;
större 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 procedur - 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"

Skickar parametrar till Turbo Pascal

1. Skicka parametrar efter värde

Värdeparametrar – variabler deklarerade efter procedurens namn inom 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"

Skickar parametrar till Turbo Pascal

2. Skicka parametrar efter namn

Variabla parametrar – variabler som deklareras 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; Varmin: 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 |