Plugins - Pascal. Egendefinerte moduler i pascal Arbeide med standardmoduler i pascal-eksempler
Moduler i Pascal i forhold til hoveddelen av programmet ligner de på subrutiner (prosedyrer og funksjoner). Men per definisjon er de uavhengige programmer hvis ressurser kan brukes i andre programmer. I tillegg forekommer beskrivelsen av moduler utenfor den anropende applikasjonen, men i en egen fil, så en modul er et separat kompilert program. Den kompilerte modulfilen (dette er nøyaktig hva som er nødvendig for bruk) vil ha utvidelsen levert av programmeringsmiljøet (for eksempel .tpu, .ppu, .pcu).
Moduler er som regel laget for å sikre kodekompakthet, som store prosjekter må bekymre seg for. Det er også verdt å merke seg at bruken av moduler på en måte fjerner begrensningen på minnesegmentering, siden koden for hver modul er plassert i et eget segment.
Modulstrukturen ser slik ut:
Enhet<имя модуля>;
Grensesnitt
<интерфейсная часть>
Implementering
<исполняемая часть>
Begynne
<инициализация>
Slutt.
Enhetsnavn
Modulnavn etter nøkkelordet Enhet, må samsvare med navnet på filen (uten .pas) der koden er plassert. Ved å bruke navnet kobles modulen til en annen modul, eller til hovedprogrammet. For å gjøre dette må du spesifisere et tjenesteord Bruker, og lister listen over plugin-moduler atskilt med komma:
Bruker<список имен модулей>;
Grensesnitt del
Grensesnittdelen beskriver overskriftene til objekter som andre moduler og programmer vil ha tilgang til. Dette er konstanter, typer, variabler og subrutiner. Dette er for eksempel hvordan grensesnittdelen av søkemodulen kan se ut, som inneholder algoritmer for å søke i elementer i en matrise.
|
1 |
enhet Søk; |
For å erklære denne modulen, må du spesifisere navnet i programmet:
Deretter vil det være mulig å bruke alle objektene beskrevet i grensesnittdelen.
Implementering
Denne delen begynner med ordet Implementering(gjennomføring). Det er her du må beskrive subrutinene som er deklarert i grensesnittdelen. Samtidig er det tillatt å ikke angi formelle parametere i overskriftene deres, ellers må de falle helt sammen med de i grensesnittdelen. I tillegg kan grensesnittdelen inneholde objekter som er lokale (utilgjengelige for det anropende programmet) for modulen.
Initierende del
Den initierende delen begynner arbeidet før utførelsen av hovedprogrammet starter. Den (mellom Begin og End) beskriver som regel operatører beregnet på ulike typer hjelpearbeid. Denne delen kan mangle eller ikke ha noen kode. I det første tilfellet må du spesifisere Slutt med en prikk, i det andre, la det være tomt i Start og End.
Kompilere moduler
Du kan bare bruke kompilerte moduler i programmet som har utvidelsen levert av applikasjonsutviklingsmiljøet ditt. La oss se på de tre mest populære av dem:
Turbo Pascal
Resultatet av å kompilere modulen i Turbo Pascal vil være en fil med utvidelsen .tpu (Turbo Pascal enhet), lagrer koden.
Gratis Pascal
Etter å ha kompilert modulen i Free Pascal, opprettes to filer med forskjellige oppløsninger: .ppu Og .o. Den første inneholder grensesnittdelen av modulen, og den andre (nødvendig for å komponere programmet) inneholder en del av implementeringene.
Pascal ABC.NET
Pascal ABC.Net genererer ikke maskinspråkkode under modulkompilering. Hvis kompileringen er vellykket, lagres koden i en fil med tillatelse .pcu.
Det er tre kompileringsmoduser for programmeringsmiljøene Turbo Pascal og Free Pascal: Kompiler, lag og bygg. I kompileringsmodus må alle moduler som brukes i programmet være kompilert på forhånd. Applikasjonen i Lag kompileringsmodus sjekker alle tilkoblede moduler for tilstedeværelse av filer med passende oppløsning for programmeringsmiljøet (.tpu eller .o). Hvis noen av dem ikke blir funnet, søkes det i en fil med navnet på modulen som ikke ble funnet og filtypen .pas. Den mest pålitelige modusen er Build. Søking og kompilering av filer (med filtypen .pas) i denne modusen skjer selv når modulære filer allerede eksisterer.
Eksempel
La oss lage en liten modul som inneholder prosedyrer for binært og lineært søk av elementer i en matrise. Modulkode:
|
1 |
enhet Søk; |
All denne koden skal være i en egen fil. La oss nå skrive hovedprogrammet som vi skal koble søkemodulen vår til.
Modul
(ENHET-modul, unit) er en autonomt (separat) kompilert programenhet som inneholder komponenter i beskrivelsesdelen (etiketter, konstanter, typer, variabler, prosedyrer, funksjoner), og kan også inneholde operatører for initialiseringsdelen.
Modulen i seg selv er ikke et kjørbart program, men er ment å brukes av andre programmer og moduler.
Modulstruktur
Modulen har følgende struktur:
ENHET<
modulnavn >
GRENSESNITT
<
grensesnittdelen >
IMPLEMENTERING
<
implementeringsdelen >
BEGYNNE
<
initialiseringsseksjonen >
SLUTT.
Modultittel består av et reservert ord Enhet(modul) og modulnavnet.
Navnet på modulen velges i henhold til generelle regler og må samsvare med navnet på diskfilen som inneholder kildekoden til modulen.
Utvidelsen i modulnavnet (. pas
) er ikke spesifisert, den er satt som standard.
Modulnavnet brukes til å koble det til hovedprogrammet ved hjelp av en klausul Bruker .
Tilby Bruker M.B. plassert etter modultittelen eller etter ordene
Grensesnitt Og Implementering .
Grensesnitt del Grensesnitt(grensesnitt, artikulasjon, tilkobling) og inneholder referanser til andre moduler og deklarasjoner (beskrivelser) av globale objekter, dvs. etiketter, konstanter, typer, variabler og overskrifter for prosedyrer og funksjoner som er tilgjengelige for hovedprogrammet og andre moduler (dvs. synlige fra utsiden).
Implementeringsseksjonen – starter med et nøkkelord Implementering(utførelse) og inneholder en beskrivelse av objekter som er lokale for modulen, dvs. etiketter, konstanter, typer, variabler som ikke er tilgjengelige for hovedprogrammet og andre moduler (dvs. ikke er synlige fra utsiden) og en fullstendig beskrivelse av prosedyrer og funksjoner. I dette tilfellet er det i overskriften til subrutinene en liste over formelle parametere. utelatt, men hvis det er gitt, må det samsvare nøyaktig med beskrivelsen i grensesnittdelen.
Initialiseringsseksjon
– satt i verbale parentes BEGYNNE SLUTT.
og inneholder setninger som vil bli utført før kontrollen overføres til hovedprogrammet. Dette kan være data (variable) initialiseringsoperatorer For eksempel tildelings- og inndataoperatorer, samt prosedyrer for kobling og åpning av filer. Operatørseksjonen m.b. tømme BEGYNNE SLUTT eller bare være fraværende SLUTT .
Det er en periode på slutten av modulen.
Kompilere og bruke moduler
Systemets RAM har en segmentstruktur (ett segment er lik 64K = 65535 byte). Programkode m.b. ikke mer enn ett segment, datavolumet kan ikke overstige ett segment (med mindre dynamisk minne brukes) og ett segment for stabelen. Stabelstørrelsen er satt av direktivet ($M<>). Minste stabelstørrelse er 1K, standard maksimum ett segment er 16K. Verdiene til lokale variabler skyves inn på stabelen når du kaller en subrutine, og sprettes fra stabelen når du går ut.
Modulkoden er plassert i et eget segment, fordi det oversettes uavhengig av hovedprogrammet, og antall moduler som brukes av programmet avhenger bare av tilgjengelig OP. Dette lar deg lage store programmer.
Kompilatoren lager modulkode med samme navn, men med utvidelsen tpu
(turbo pascal enhet).
For å bruke en modul av hovedprogrammet eller andre moduler, plasseres dens navn (uten utvidelse) i setningslisten Bruker
Hvis modulen er kompakt og ofte m.b. brukes av applikasjonsprogrammer, kan den plasseres i biblioteket med standardmoduler TURBO.TPL (Turbo-Pasacal-bibliotek )
ved hjelp av verktøyet TPUMOVER.
Men dette bør bare gjøres i nødstilfeller fordi... biblioteket lastes inn i OP og reduserer plassen for programmet.
Når du kompilerer en fil med kildeteksten til en modul, vises en fil med samme navn med filtypen tpu
og er plassert i katalogen spesifisert av alternativet
ALTERNATIVER/KATALOGER/ENHETSKAP
eller i gjeldende katalog hvis dette alternativet ikke er tilgjengelig.
Ved kompilering av hovedprogrammet må modulene som brukes være i katalogen spesifisert av alternativet
ALTERNATIVER/KATALOGER/EXE- & TPU-KATALOGER
eller i gjeldende katalog hvis dette alternativet mangler
Å motta EXE oppgavefil i alternativet
SAMLER/DESTINASJON/DISK(MEMORI)
installere DISK
.
Det er tre modulkompileringsmoduser:
- SAMLER
- BYGG
- LAGE
Modus er satt av menyen SAMLER
1. Modus SAMLER(ringes Alt-F9
). I dette tilfellet kompileres programmet og modulene som brukes må kompileres. forhåndskompilert og lagret i passende kataloger.
2. Modus BYGGE(ringes -
F9). I dette tilfellet ignoreres tidligere kompilerte moduler, og det søkes etter moduler med utvidelsen pas
og er rekompilert.
3. Modus LAGE(ringes F9). I dette tilfellet er det kun moduler som hadde endringer i teksten som kompileres på nytt.
Eksempel 16.1.
I fil inp.txt det er tre matriser med reelle tall
2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Vurder funksjon
hvor Max_a, Max_b, Max_c, Sa, Sb, Sc, ka, kb, kc - det maksimale elementet, summen og antallet positive elementer i de tilsvarende matrisene a, b og c.
Send resultatet til en fil ute.
txt
og på skjermen.
Modultekst
Enhet UNMAS;
Grensesnitt
Konst n=10;
Skriv vec=array of real;
Var z:vec;
i:heltall;
f1,f2:tekst;
Prosedyre SK1(z:vec; antall:byte; Var s:reell; Var k:byte);
Funksjon MAX(z:vec; antall:byte):reell;
Implementering
Prosedyre Vv(s:char; num:byte;Var z:vec);
Begynne
Writeln("Array",s);
For i:=1 til num do
Begynne
Read(f1,z[i]); Skriv(z[i]:4:1," ":3);
Slutt;
Lesln(f1); Writeln;
Slutt;
Prosedyre SK1(z:vec;antall:byte; Var s:reell; Var k:byte);
Begynne
s:=0; k:=0;
for i:=1 til num gjør hvis z[i]>0 da
Begynne
s:=s+z[i];
k:=k+1
Slutt;
Slutt;
Funksjon MAX(z:vec;antall:byte):reell;
Var m:ekte;
Begynne
m:=z;
for i:=1 til num gjør hvis z[i]>m så m:=z[i];
MAX:=m
Slutt;
Begynne
Tilordne(f1,"inp.txt"); Tilbakestill(f1);
Assign(f2,"out.txt"); Omskriv(f2)
Slutt.
Programtekst
Program lr7_16;
Bruker CRT,UNMAS;
Var
a,b,c:vec;
y,sa,sb,sc:real;
ka,kb,kc:byte;
Begynne
clrscr;
Vv("a",8,a);
Vv("b",9,b);
Vv("c",n,c);
SK1(a,8,sa,ka);
SK1(b,9,sb,kb);
SK1(c,n,sc,kc);
y:=(MAX(a,8)+MAX(b,9)+MAX(c,n))+(sa+sb+sc+ka+kb+kc);
Writeln("Resultat:":20);
Write("Array a:");
Writeln("sa=",sa:5:1," ka=",ka);
Write("Array b:");
Writeln("sb=",sb:5:1," kb=",kb);
Write("Array c:");
Writeln("sc=",sc:5:1," kc=",kc);
Writeln(" ":10,"y=",y:10);
Readln;
Writeln(f2,"ђҐ§г"мв в:");
Writeln(f2," ":10,"y=",y:10);
Lukk(f1);
Lukk(f2)
Slutt.
Programresultater
Array a
-2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Array b
2.3 -4.3 2.1 2.5 -3.7 -5.6 4.6 3.5 -7.5
Array c
-2.1 4.3 -2.3 7.6 4.5 -8.9 5.7 -4.5 6.8 -5.8
Resultat:
Array a: sa= 17,6 ka=4
Matrise b: sb= 15,0 kb=5
Array c: sc= 28,9 kc=5
y= 9,330E+01
Plug-ins.
1. Grunnleggende bestemmelser
Plug-in modul– en fil som inneholder kildetekst på Pascal-språket, med en viss struktur, beregnet for bruk både i hovedprogrammet og i andre plug-ins. Bruk er å inkludere en modul i bruksdelen ved å spesifisere navnet.2. Generell struktur for plug-in-modulen
Enhet<имя модуля>; Grensesnittimplementering slutt.
Strukturelt kan plug-in-modulen deles inn i tre seksjoner: 1) Grensesnittseksjon - grensesnitt (må deklareres, kan være tom) 2) Implementeringsseksjon - implementering (må deklareres, kan være tom) 3) Modulkropp - begynne -slutt. (kan mangle)
2.1. Grensesnittseksjon.
Grensesnittseksjon– plugin-område, som starter med grensesnittnøkkelordet og slutter med implementeringsnøkkelordet, som kan inneholde: - en liste over plugin-moduler; - konstanter;- tilpassede datatyper; - variabler; som i programmet, kan de ovennevnte seksjonene (erklæringer av konstanter, variabler, etc., med unntak av bruksseksjonen) i denne seksjonen ordnes i hvilken som helst rekkefølge og i hvilken som helst mengde. Merknad 3: Hvis prototyper av prosedyrer/funksjoner er deklarert i denne seksjonen, må implementeringen deres garantert finnes i implementeringsseksjonen. Hovedformål: definerer offentlige data/funksjonalitet for bruk fra et program eller en modul som bruker denne modulen.Eksempel på en grensesnittseksjon:
Grensesnitt (plugin-moduler) Bruker AnotherUnit; (konstanter) Konst PI=3,14159265;
E=2,71828182; (egendefinerte datatyper) Type TMyType=array[-3..7] av ekte; (variabler) Var temp:TMyType; (prosedyrer og funksjoner) Prosedyre Fyll(var x:TMyType); Funksjon Finn(const x:TMyType; const Verdi:real):Boolsk; Implementering
2.2. Implementeringsseksjonen. Implementeringsseksjonen Hovedformål:– området til plugin-modulen, som starter med nøkkelordimplementeringen og slutter med modulens brødtekst (hvis det er en) eller nøkkelordet slutter med en prikk som indikerer slutten av modulen, der implementeringer av prosedyrer og funksjoner som er deklarert i grensesnittdelen er lokalisert, som kan inneholde: - en liste over plug-ins-moduler; - konstanter;- konstanter;- tilpassede datatyper;
- variabler;
- prosedyrer og funksjoner som er nødvendige for å implementere prosedyrene/funksjonene som er deklarert i grensesnittdelen.
implementering av prosedyrer og funksjoner beskrevet i grensesnittdelen.
Når du implementerer prosedyrer og funksjoner beskrevet i grensesnittdelen, kan overskriftene deres beskrives i forkortet form. Unntak - PascalABC: når du bruker headervariabler i implementeringsteksten, oppstår det en kompileringsfeil.
Eksempel 1 (overskrifter i forkortet form): Unit DemoUnit; Grensesnitt (prosedyreprototype) Prosedyre Swap(var a,b:heltall); Bytte av implementeringsprosedyre; Var Temp:heltall; Start Temp:=a; Hovedformål: initialisering av modulvariabler, allokering av ressurser som er nødvendige for driften, etc.Eksempel på en modul som inneholder en kropp:
Unit DemoUnit; Grensesnittkonst N=50; Var Røtter: rekke ekte; Implementering bruker matematikk; Var I:heltall; (modulkropp) Begynn For i:=1 til N gjør Røtter[i]:=sqrt(i); Slutt.
Eksempel på en modul uten brødtekst: (se eksempel på en modul for overskrifter i full form).
- konstanter; Programkoden som ligger i hoveddelen av modulen utføres én gang - når modulen er lastet, før utførelsen av hovedprogramkoden begynner. - variabler; I tilfellet når flere moduler som har initialiseringsseksjoner er koblet til i bruksdelen, utføres koden til disse seksjonene i den rekkefølgen modulene er koblet til.2.4. Tilleggsseksjoner i modulstrukturen.
Free Pascal, Pascal ABC, Pascal ABC.Net kompilatorene tillater, i tillegg til de som er oppført ovenfor, ytterligere to seksjoner: - en initialiseringsseksjon - en sluttføringsseksjon. 2.4.1. Initialiseringsseksjon. Initialiseringsseksjon – plugin-området plassert etter slutten av implementeringsdelen, som starter med initialiseringsnøkkelordet og slutter med finaliseringsseksjonen, hvis det er en, eller sluttnøkkelordet etterfulgt av en prikk. Hensikten er lik modulkroppen. 2.4.2. Avslutningsseksjon. Hovedformål: Avslutningsseksjon
– et plugin-område plassert på slutten av initialiseringsdelen, hvis det er en, eller på slutten av implementeringsdelen, og slutter med sluttnøkkelordet etterfulgt av en prikk.
- konstanter; frigjøre ressurser tildelt for moduldrift. - variabler; enhet DemoUnit; interface var a:array of ^integer;(array of pointers) implementering (minnetildeling og initialisering med verdier) prosedyre AllocateArray; var i:heltall; start for i:=1 til 20 begynner New(a[i]);a[i]^:=i;
slutt; slutt; (deallokering av minne) prosedyre DeallocateArray; var i:heltall; begynne for i:=1 til 20 do Dispose(a[i]); slutt; initialisering AllocateArray;(initialisering - start av arbeid - alloker minne) avslutning DeallocateArray;(avslutning - slutt på arbeid - frigjør minne) slutt.
Programkoden som er plassert i de oppførte delene, utføres én gang. Koden til initialiseringsseksjonene er før starten av kjøringen av hovedprogramkoden, koden til avslutningsseksjonene er etter.
Resultatet av å kompilere en plug-in til Turbo Pascal er en *.tpu-fil (Turbo Pascal Compiled Unit), som er en maskinrepresentasjon av dataene og koden som ligger i den.
3.2. Kompilere i Free Pascal.
Resultatet av å kompilere en plug-in-modul i Free Pascal er to filer: *.ppu - en fil som inneholder grensesnittdelen av modulen, og en *.o-fil - en objektfil som inneholder en del av implementeringene. Dessuten er sistnevnte nødvendig for å komponere søknaden.
3.3. Samling i Pascal ABC.Net.
I motsetning til miljøene som er oppført ovenfor, genererer ikke Pascal ABC.Net maskinspråkkode under modulkompilering. Kompilatoren av dette miljøet fullfører arbeidet sitt etter å ha utført en semantisk analyse, og lagrer det semantiske treet til modulen i et mellomformat - *.pcu - en fil som, til en første tilnærming, kan betraktes som et resultat av kompilering med de angitte begrensningene .
3.4. Fremskynder programsamlingen.
På applikasjonskoblingsstadiet setter linkeren sammen en kjørbar modul, og tar objektmoduler som input. Dermed, etter å ha kompilert plug-ins, er kompilering av programmer ved hjelp av dem raskere, siden de allerede er behandlet. Dette gjelder for Turbo og Free Pascal. Men i Pascal ABC.Net oppnås kompileringshastigheten bare på grunn av det faktum at det ikke er behov for å utføre syntaktisk og semantisk analyse. Konklusjon: kompilerte versjoner av kjørbare moduler er ikke kompatible mellom forskjellige kompilatorer.
Kode for oppgaven: "Plug-ins"
Tekstlig
Programliste
Enhet u1; grensesnittprosedyre PrintFirst; prosedyre PrintFirstSecond; implementering bruker u2; (<--- Раньше было в Interface } procedure PrintFirst; begin writeln("Print first"); end; procedure PrintFirstSecond; begin writeln("Print first"); PrintSecond; end; end.
Moduler i Pascal, i forhold til hoveddelen av programmet, ligner subrutiner (prosedyrer og funksjoner). Men per definisjon er de uavhengige programmer hvis ressurser kan brukes i andre programmer. I tillegg er modulene beskrevet utenfor den anropende applikasjonen, men i en egen fil, så en modul er et separat kompilert program. Den kompilerte modulfilen (dette er nøyaktig hva som er nødvendig for bruk) vil ha utvidelsen levert av programmeringsmiljøet (for eksempel .tpu, .ppu, .pcu).
Moduler er som regel laget for å sikre kodekompakthet, som store prosjekter må bekymre seg for. Det er også verdt å merke seg at bruken av moduler på en måte fjerner begrensningen på minnesegmentering, siden koden for hver modul er plassert i et eget segment.
Modulstrukturen ser slik ut:
Enhet<имя модуля>; Grensesnitt<интерфейсная часть>Implementering<исполняемая часть>Begynne<инициализация>Slutt.
Enhetsnavn
Modulnavnet etter Unit-nøkkelordet må samsvare med navnet på filen (uten .pas) der koden er plassert. Ved å bruke navnet kobles modulen til en annen modul, eller til hovedprogrammet. For å gjøre dette må du spesifisere tjenesteordet Uses, og liste listen over plug-ins atskilt med komma:
Bruker<список имен модулей>;
Grensesnitt del
Grensesnittdelen beskriver overskriftene til objekter som andre moduler og programmer vil ha tilgang til. Dette er konstanter, typer, variabler og subrutiner. Dette er for eksempel hvordan grensesnittdelen av søkemodulen kan se ut, som inneholder algoritmer for å søke i elementer i en matrise.
Enhetssøk; Grensesnitttype arr = array av heltall; var s: streng; prosedyre binært_søk(x: heltall; Ar: arr; var s: streng); prosedyre line_search(x: heltall; Ar: arr; var s: streng);
For å erklære denne modulen, må du spesifisere navnet i programmet:
Deretter vil det være mulig å bruke alle objektene beskrevet i grensesnittdelen.
Implementering
Denne delen begynner med ordet Implementering. Det er her du må beskrive subrutinene som er deklarert i grensesnittdelen. Samtidig er det tillatt å ikke angi formelle parametere i overskriftene deres, ellers må de falle helt sammen med de i grensesnittdelen. I tillegg kan grensesnittdelen inneholde objekter som er lokale (utilgjengelige for det anropende programmet) for modulen.
Initierende del
Den initierende delen starter sitt arbeid før utførelsen av hovedprogrammet starter. Den (mellom Begin og End) beskriver som regel operatører beregnet på ulike typer hjelpearbeid. Denne delen kan mangle eller ikke ha noen kode. I det første tilfellet må du spesifisere Slutt med en prikk, i det andre, la det være tomt inne i Start og End .
Kompilere moduler
Du kan bare bruke kompilerte moduler i programmet som har utvidelsen levert av applikasjonsutviklingsmiljøet ditt. La oss se på de tre mest populære av dem:
kompilere moduler i Turbo Pascal
Resultatet av å kompilere modulen til Turbo Pascal, vil det være en fil med filtypen .tpu (Turbo Pascal enhet), lagrer koden.
kompilere moduler i Free Pascal
Etter å ha kompilert modulen i miljøet Gratis Pascal, to filer opprettes med forskjellige oppløsninger: .ppu Og .o. Den første inneholder grensesnittdelen av modulen, og den andre (nødvendig for å komponere programmet) inneholder en del av implementeringene.
kompilere moduler i Pascal ABC.NET
Pascal ABC.Net genererer ikke maskinspråkkode under modulkompilering. Hvis kompileringen er vellykket, lagres koden i en fil med permission.pcu.
Det er tre kompileringsmoduser for programmeringsmiljøene Turbo Pascal og Free Pascal: Kompiler, Lag og Bygg. I kompileringsmodus må alle moduler som brukes i programmet være kompilert på forhånd. Applikasjonen i Lag kompileringsmodus sjekker alle tilkoblede moduler for tilstedeværelse av filer med passende oppløsning for programmeringsmiljøet (.tpu eller .o). Hvis noen av dem ikke blir funnet, søkes det i en fil med navnet på modulen som ikke ble funnet og filtypen .pas. Den mest pålitelige modusen er Build. Søking og kompilering av filer (med filtypen .pas) i denne modusen skjer selv når modulære filer allerede eksisterer.
Eksempel: la oss lage en liten modul som inneholder prosedyrer for binært og lineært søk av elementer i en matrise. Modulkode:
Enhetssøk; Grensesnitttype arr = array av heltall;<=b do
begin
c:=a+(b-a) div 2;
if (x
prosedyre binært_søk(x: heltall; Ar: arr; var s: streng);
prosedyre line_search(x: heltall; Ar: arr; var s: streng); Implementering var a, b, c, i: heltall;
prosedyre binært_søk(x: heltall; Ar: arr; var s: streng); begynne a:=1; b:=5; s:="NEI";