Hva er programmering? Programmerings språk. Dataprogramering. Programmering hva betyr det; definisjon av begrepet mening

Definisjoner [ | ]

En sekvens av instruksjoner designet for å bli utført gjentatte ganger kalles syklusens kropp... En enkelt utførelse av en loop-kropp kalles en iterasjon. Uttrykket som bestemmer om iterasjonen skal utføres igjen eller løkken skal avsluttes, kalles utgangstilstand eller betingelsen for slutten av syklusen(eller betingelse for fortsettelse avhengig av hvordan dens sannhet tolkes - som et tegn på behovet for å fullføre eller fortsette syklusen). Variabel lagring nåværende nummer iterasjon kalles iterasjonsteller sykle eller bare syklusteller... Sløyfen inneholder ikke nødvendigvis en teller, telleren trenger ikke å være en - betingelsen for å gå ut av sløyfen kan avhenge av flere variabler endret i sløyfen, eller den kan bestemmes ytre forhold(for eksempel når en viss tid kommer), i sistnevnte tilfelle kan det hende at telleren ikke er nødvendig i det hele tatt.

Utførelse av en hvilken som helst sløyfe inkluderer initialisering av sløyfevariablene, kontroll av utgangstilstanden, kjøring av sløyfekroppen og oppdatering av sløyfevariabelen ved hver iterasjon. I tillegg gir de fleste programmeringsspråk midler for tidlig sløyfekontroll, for eksempel sløyfetermineringssetninger, det vil si å gå ut av løkken uavhengig av sannheten i utgangstilstanden (i C, pause) og operatører for å hoppe over iterasjon (i C , Fortsette).

Typer av sykluser [ | ]

Ubetingede løkker[ | ]

Noen ganger bruker programmer løkker, hvis utgang ikke er gitt av logikken til programmet. Slike løkker kalles ubetingede, eller endeløse. Spesiell syntaktiske virkemidler for å lage endeløse sykluser, på grunn av deres atypiske natur, gir ikke programmeringsspråk, derfor lages slike løkker ved hjelp av konstruksjoner designet for å lage vanlige (eller betinget) sykluser. For å sikre uendelig repetisjon, er betingelseskontrollen i en slik løkke enten fraværende (hvis syntaksen tillater, som for eksempel i løkken SLØKKE ... SLUKKE Ada-språk), eller erstattes av en konstant verdi ( mens sant gjør... i Pascal). Språket bruker en loop for (;;) med tomme seksjoner eller løkke mens (1).

Løkke med forutsetning[ | ]

En løkke med en forutsetning er en løkke som utføres så lenge en bestemt betingelse spesifisert før dens begynnelse er sann. Denne tilstanden er sjekket før utførelse av loop-kroppen, så kroppen kan ikke utføres en gang (hvis betingelsen er falsk helt fra begynnelsen). Mest prosessuelle språk programmering implementeres av operatøren samtidig som, derav dets andre navn - while-loop. På Pascal en løkke med en forutsetning ser slik ut:

samtidig som< условие >begynne< тело цикла >slutt;

samtidig som (< условие > ) { < тело цикла > }

Løkke med postcondition[ | ]

Sløyfe med postcondition - en sløyfe der tilstanden kontrolleres etter utførelse av løkkelegemet. Det følger at kroppen alltid henrettet i hvert fall en gang. I Pascal implementeres denne løkken av repetisjonssetningen..until; i C, gjør ... mens.

I Pascal ser en postcondition-løkke slik ut:

gjenta< тело цикла >før< условие выхода >

På C-språk:

gjør (< тело цикла >) samtidig som (< условие продолжения цикла > )

I tolkningen av en syklustilstand med en postbetingelse i forskjellige språk det er forskjeller. I Pascal og språkene som er avledet fra den, tolkes tilstanden til en slik syklus som utgangstilstand(syklusen avsluttes når betingelsen er sann, i russisk terminologi kalles slike sykluser også "syklus før"), og i C og dens etterkommere - som fortsettelse tilstand(løkken slutter når betingelsen er falsk; slike looper kalles noen ganger en "bye loop").

Sløyfe med utgang fra midten[ | ]

Midt-ut-løkken er mest generell form betinget loop. Syntaktisk er en slik loop formatert med ved hjelp av tre konstruksjoner: begynnelsen av loopen, slutten av loopen og kommandoen for å gå ut av loopen. Startkonstruksjonen markerer punktet i programmet der hoveddelen av loopen begynner, og sluttkonstruksjonen markerer punktet der kroppen slutter. Inne i kroppen må det være en kommando for å gå ut av loopen, når den utføres avsluttes loopen og kontrollen overføres til setningen etter slutten av loopkonstruksjonen. Naturligvis, for at løkken skal utføres mer enn én gang, bør exit-kommandoen ikke kalles ubetinget, men bare når sløyfeutgangsbetingelsen er oppfylt.

Den grunnleggende forskjellen mellom denne typen sløyfe og de som er vurdert ovenfor, er at den delen av sløyfen som ligger etter starten av sløyfen og før exit-kommandoen alltid utføres (selv om sløyfeutgangsbetingelsen er sann ved første iterasjon), og den delen av løkkelegemet som ligger etter exit-kommandoen, blir ikke utført ved siste iterasjon.

Det er lett å se at ved å bruke en sløyfe med en utgang fra midten, kan du enkelt modellere både en sløyfe med en forutsetning (ved å plassere en utgangskommando i begynnelsen av sløyfekroppen) og en sløyfe med en postbetingelse (ved å plassere en exit-kommando på slutten av løkken).

Noen programmeringsspråk inneholder spesielle konstruksjoner for å organisere en løkke med en utgang fra midten. Så, på Ada-språket, brukes konstruksjonen til dette SLØKKE ... SLUKKE og exit-kommandoen EXIT eller AVSLUTT NÅR:

LOOP ... En del av kroppen til EXIT WHEN-løkken< условие выхода >; ... Kroppsdel ​​av IF-løkken< условие выхода >SÅ AVSLUTT; SLUTT; ... Kroppsdelen av ENDLOOPEN:

Her, innenfor loopen, kan det være et hvilket som helst antall utgangskommandoer av begge typer. Utgangskommandoene i seg selv er vanligvis ikke fundamentalt forskjellige AVSLUTT NÅR brukes når kun utgangstilstanden er sjekket, men enkelt EXIT- når løkken forlates i en av variantene av en kompleks betinget operatør.

På språk der slike konstruksjoner ikke er gitt, kan en løkke med en utgang fra midten modelleres ved å bruke en hvilken som helst betinget sløyfe og en tidlig utgangsoperator (som f.eks. gå i stykker i C, exit i Turbo Pascal, etc.), eller den ubetingede hoppoperatøren gå til.

Motsyklus (eller syklus for)[ | ]

En sløyfe med en teller er en løkke der en variabel endrer verdien fra en gitt startverdi til dens endelige verdi med et eller annet trinn, og for hver verdi av denne variabelen utføres løkkens kropp én gang. I de fleste prosedyreprogrammeringsspråk implementeres det av operatøren til, der telleren er indikert (den såkalte "syklusvariabelen"), det nødvendige antall passeringer (eller grenseverdien for telleren) og muligens trinnet som telleren endres med. For eksempel, på Oberon-2-språket, ser en slik syklus ut som:

her er v telleren, b er startverdien til telleren, e er grenseverdien til telleren, s er trinnet).

Spørsmålet om verdien av en variabel på slutten av en løkke der denne variabelen ble brukt som teller er tvetydig. For eksempel, hvis et Pascal-program inneholder en konstruksjon av skjemaet:

i: = 100; for i: = 0 til 9 begynner ... løkkelegemet slutt; k: = i;

spørsmålet oppstår: hvilken verdi vil til slutt tildeles til variabelen k: 9, 10, 100, kanskje noe annet? Hva om syklusen avsluttes før skjema? Svarene avhenger av om tellerverdien økes etter siste iterasjon og om oversetteren endrer denne verdien i tillegg. Et spørsmål til: hva skjer hvis en ny verdi eksplisitt tildeles telleren inne i loopen? Ulike programmeringsspråk løser disse problemene på forskjellige måter. Hos noen er oppførselen til disken tydelig regulert. I andre, for eksempel i samme Pascal, definerer ikke språkstandarden verken den endelige verdien av telleren, eller konsekvensene av dens eksplisitte endring i løkken, men anbefaler ikke å endre telleren eksplisitt og bruke den på slutten av løkken uten reinitialisering. Et Pascal-program som ignorerer denne anbefalingen kan gi andre resultater når det kjøres på ulike systemer og bruke forskjellige oversettere.

Spørsmålet på Ada-språket har blitt radikalt løst: telleren anses som beskrevet i overskriften til syklusen, og utenfor den eksisterer den rett og slett ikke. Selv om navnet på telleren allerede er brukt i programmet, brukes en egen variabel som teller inne i loopen. Det er forbudt å eksplisitt tilordne noen verdier til telleren; den kan bare endres av den interne mekanismen til løkkeoperatøren. Som et resultat, konstruksjonen

i: = 100; for i i (0.. 9) løkke ... kroppen av løkken endeløkke; k: = i;

eksternt lik syklusen ovenfor i Pascal, den tolkes entydig: variabelen k vil bli tildelt verdien 100 fordi variabelen Jeg brukt av utenfor denne syklusen, har ingenting med disken å gjøre Jeg som skapes og endres inne i løkken... Slik isolering av telleren er praktisk og sikker: ingen separat beskrivelse er nødvendig for den, og sannsynligheten for tilfeldige feil assosiert med utilsiktet ødeleggelse av variabler utenfor syklusen er minimal. Hvis programmereren må inkludere i klar kode løkke med en teller, kan det hende at den ikke sjekker om en variabel med navnet den har valgt som teller eksisterer, ikke legger til en beskrivelse av en ny teller i overskriften til den tilsvarende prosedyren, ikke prøver å bruke en av de eksisterende , men i dette øyeblikket"Gratis" tellere. Han skriver ganske enkelt en løkke med en tellervariabel, hvis navn er praktisk for ham, og kan være sikker på at ingen navnekollisjon vil oppstå.

En sløyfe med en teller kan alltid skrives som en betinget sløyfe, før starten tildeles telleren en startverdi, og utgangsbetingelsen er når telleren når sin endelige verdi; i dette tilfellet blir en operatør for å endre telleren med et gitt trinn lagt til syklusens hoveddel. men spesielle operatører løkker med en teller kan oversettes mer effektivt, siden den formaliserte formen til en slik løkke tillater bruk av spesielle prosessorkommandoer for å organisere løkker.

På noen språk, for eksempel, stammet C og andre fra den, syklusen til til tross for den syntaktiske formen til en løkke med en teller, er det faktisk en løkke med en forutsetning. Det vil si at i C er løkkekonstruksjonen:

for (i = 0; i< 10 ; ++ i ) { ... тело цикла }

representerer faktisk en annen form for notasjon for konstruksjonen:

i = 0; mens jeg< 10 ) { ... тело цикла ++ i ; }

Altså i designet til først skrives en vilkårlig erklæring om initialisering av løkken, deretter en fortsettelsesbetingelse og til slutt en bestemt operasjon utført etter hver kropp av løkken (dette trenger ikke å være en endring i telleren; det kan være en pekerredigering eller en helt uvedkommende operasjon). For språk av denne typen kan problemet ovenfor løses veldig enkelt: tellervariabelen oppfører seg på en fullstendig forutsigbar måte, og etter slutten av loopen beholder den sin siste verdi.

Felles syklus [ | ]

En annen versjon av løkken er en løkke som spesifiserer utførelsen av en operasjon for objekter fra et gitt sett, uten eksplisitt å spesifisere rekkefølgen som disse objektene er oppregnet i. Slike sykluser kalles ledd(og går gjennom samlingen, se sykluser) og representerer en formell registrering av en instruksjon av skjemaet: "Utfør operasjon X for alle elementer inkludert i settet M". Fellesløkken bestemmer i teorien ikke på noen måte i hvilken rekkefølge operasjonen skal brukes på elementene i settet, selv om spesifikke programmeringsspråk selvfølgelig kan spesifisere en spesifikk rekkefølge for iterering over elementene. Vilkårlighet gjør det mulig å optimalisere utførelsen av syklusen ved å organisere tilgang ikke i en gitt programmerer, men i den mest fordelaktige rekkefølgen. Hvis det er mulighet for parallell utførelse av flere operasjoner, er det til og med mulig å parallellisere utførelsen av en felles sløyfe, når samme operasjon utføres samtidig på forskjellige datamoduler for forskjellige objekter, mens programmet forblir logisk konsistent.

Fellesløkker er tilgjengelige på noen programmeringsspråk (f.eks. Eiffel, Java, JavaScript, Perl, Python, PHP, LISP, Tcl, etc.) - de lar deg gå gjennom alle elementene i en gitt samling av objekter. I definisjonen av en slik løkke trenger du bare å spesifisere en samling av objekter og en variabel, som i løkkens kropp vil bli tildelt verdien til det nå behandlede objektet (eller en referanse til det). V forskjellige språk programmeringsoperatørsyntaksen er forskjellig:

for (type og element: sett) // støttet siden C ++ 11 standard { // bruker element }

foreach (skriv inn element i sett) ( // bruker element }

for element i [1 .. 100] begynner // Bruke element (kodeytelse ble testet i Delphi 2010) slutt;

på tvers satt som markørsløyfe - ved å bruke cursor.item slutt

for (type element: sett) ( // bruker element }

for (txtProperty i objObject) (/ * bruk: objObject * /)

foreach ($ arr som $ element) ( / * bruker $ element * /) // eller foreach ($ arr som $-tast => $-verdi) ( / * ved å bruke indeksverdiene ​​$-nøkkelen og dens verdi $-verdi * / }

For hvert element Som type i sett "bruker element Neste element

Foreach ($ element i $ sett) (# operasjoner med $ element)

$ sett | ForEach-Object (# operasjoner med $ _)

for element i iterator_instance: # bruker element

Avslutt tidlig og hopp over iterasjon[ | ]

Mange programmeringsspråk som har sykliske konstruksjoner i syntaksen har også spesifikke kommandoer som lar deg bryte rekkefølgen på disse konstruksjonene: kommandoen for å gå ut av loopen tidlig og kommandoen for å hoppe over iterasjon.

Tidlig utgang fra syklusen[ | ]

En tidlig utgangskommando brukes når det er nødvendig å avbryte utførelsen av en syklus der utgangstilstanden ennå ikke er nådd. Dette skjer for eksempel når en feil oppdages under utførelsen av løkkelegemet, deretter videre arbeid løkken er meningsløs.

Den tidlige exit-kommandoen kalles vanligvis EXIT eller gå i stykker, og handlingen ligner handlingen til den ubetingede hoppkommandoen ( gå til) til kommandoen umiddelbart etter løkken som denne kommandoen er plassert i. Så i C-språket fungerer de to løkkene nedenfor nøyaktig det samme:

// Bruke break-setningen samtidig som (< условие >< ошибка >) gå i stykker; ... operatører) ... fortsettelse av programmet // Et lignende fragment uten brudd samtidig som (< условие >) (... hvis uttalelser (< ошибка >) goto break_label; ... utsagn) break_label: ... fortsettelse av programmet

I begge tilfeller, hvis betingelsen er oppfylt i sløyfens kropp<ошибка>, vil overgangen gjøres til operatørene utpekt som "fortsettelse av programmet". Dermed maskerer operatøren for tidlig utgang fra løkken ganske enkelt et ubetinget hopp, men bruk av pause er å foretrekke fremfor å bruke goto, siden oppførselen til pause er klart definert av språket og er potensielt mindre farlig (det er, for eksempel ingen mulighet for å gjøre en feil med plasseringen eller navnet på etiketten). I tillegg bryter ikke det å eksplisitt bryte ut av løkken tidlig, strukturerte programmeringsprinsipper.

Den vanlige operatøren for tidlig utgang avbryter arbeidet i syklusen der den er direkte plassert. I en rekke programmeringsspråk er funksjonaliteten til denne operatøren utvidet, den lar deg gå ut av flere nestede løkker (se nedenfor). I slike tilfeller er syklusen du ønsker å avslutte, merket med et merke, og dette merket er angitt i erklæringen om tidlig utgang.

Hopp over iterasjon[ | ]

Denne operatøren brukes når det i gjeldende sløyfeiterasjon er nødvendig å hoppe over alle kommandoer til slutten av løkkelegemet. I dette tilfellet bør selve syklusen ikke avbrytes, betingelsene for fortsettelse eller utgang skal beregnes på vanlig måte.

I C og dets etterkommerspråk brukes operatøren som en iterasjonshoppingskommando Fortsette i løkkekonstruksjonen. Handlingen til denne operatøren ligner på det ubetingede hoppet til linjen i løkken etter den siste kommandoen. For eksempel kan C-kode som finner summen av elementene i en matrise og summen av alle positive elementer i en matrise se slik ut:

int arr [ARRSIZE]; ... // elementer i arr-matrisen ved å bruke fortsette. < ARRSIZE ; ++ i ) { sum_all += arr [ i ]; if (arr [ i ] <= 0 ) continue ; sum_pos += arr [ i ]; } // Lignende kode med goto int sum_all = 0; int sum_pos = 0; for (int i = 0; i< ARRSIZE ; ++ i ) { sum_all += arr [ i ]; if (arr [ i ] <= 0 ) goto cont_label ; sum_pos += arr [ i ]; cont_label : }

Det andre utdraget viser tydelig hvordan det fungerer. Fortsette: den overfører ganske enkelt kontroll for den siste kommandoen til løkkelegemet, og hopper over tilleggskommandoen hvis neste element i arrayet ikke tilfredsstiller betingelsen. Dermed blir bare summen av de positive elementene i matrisen akkumulert i sum_pos.

Trenge [ | ]

Fra synspunktet til strukturert programmering er kommandoene for å gå ut av loopen tidlig og fortsette iterasjon overflødige, siden deres handlinger lett kan modelleres med rent strukturelle midler. Dessuten, ifølge en rekke programmeringsteoretikere (spesielt Edsger Dijkstra), selve det faktum å bruke ikke-strukturelle midler i et program, enten det er et klassisk ubetinget hopp eller noen av dets spesialiserte former, som pause eller fortsett, er bevis på en utilstrekkelig utviklet algoritme for å løse problemet.

Men i praksis er programkoden ofte en registrering av en allerede eksisterende, tidligere formulert algoritme, som er upraktisk å resirkulere av rent tekniske årsaker. Et forsøk på å erstatte den tidlige exit-kommandoen med strukturelle konstruksjoner i slik kode viser seg ofte å være ineffektivt eller tungvint. For eksempel kodebiten ovenfor med kommandoen gå i stykker kan skrives slik:

// Tidlig utgang fra løkken uten pause bool flagg = falsk; // flagg for tidlig avslutning samtidig som (< условие >&&! flagg) (... hvis (< ошибка >) (flagg = sant;) annet (... utsagn)) ... fortsettelse av programmet

Det er lett å sørge for at fragmentet vil fungere på samme måte som de forrige, den eneste forskjellen er at på stedet for feilsøking, i stedet for umiddelbart å gå ut av loopen, settes et tidlig utgangsflagg, som er sjekkes senere i standard tilstand for å fortsette sløyfen. Men for å avvise kommandoen tidlig avslutt, måtte vi legge til en flaggbeskrivelse og en andre gren av den betingede setningen til programmet; dessuten var programlogikken "uskarp" (beslutningen om å avslutte tidlig ble tatt på ett sted, og henrettet i en annen). Som et resultat av dette har programmet verken blitt enklere, kortere eller klarere.

Situasjonen er noe annerledes med kommandoen skip iteration. Det er vanligvis veldig enkelt og naturlig erstattet av betinget operatør... For eksempel kan fragmentet ovenfor for å summere en matrise skrives slik:

int arr [ARRSIZE]; ... // Oppsummering separat alle og bare positive // elementer i arr-matrisen med erstatningen fortsetter int sum_all = 0; int sum_pos = 0; for (int i = 0; i< ARRSIZE ; ++ i ) { sum_all += arr [ i ]; if (arr [ i ] > 0 ) // Tilstand endret til det motsatte!(sum_pos + = arr [i];))

Som du kan se, var det nok å erstatte den sjekkede tilstanden med den motsatte og plassere den siste delen av løkkekroppen i en betinget uttalelse. Du kan se at programmet har blitt kortere (på grunn av fjerning av skip iteration-kommandoen) og samtidig mer logisk (du kan se direkte fra koden at positive elementer summeres).

I tillegg kan bruk av skip iteration-kommandoen i en sløyfe med en betingelse (while-loop) også provosere frem en ukjent feil: hvis sløyfekroppen, som ofte er tilfelle, ender med kommandoer for å endre sløyfevariabelen(e), så kommandoen skip iteration vil hoppe over disse kommandoene også, som et resultat av at (avhengig av tilstanden som hoppet oppstår under) kan det oppstå en løkke eller iterasjonsrepetisjon som ikke samsvarer med algoritmen. Så hvis vi erstatter i eksemplet ovenfor for løkke på mens får du følgende:

int arr [ARRSIZE]; ... int sum_all = 0; int sum_pos = 0; int i = 0; mens jeg< ARRSIZE ) // Løkken ser ut som den forrige for ...(sum_all + = arr [i]; if (arr [i]<= 0 ) continue ; sum_pos += arr [ i ]; ++ i ; // ... men denne kommandoen vil bli hoppet over når fortsett utføres // og programmet vil gå i loop }

Til tross for deres begrensede nytte og muligheten for å erstatte dem med andre språkkonstruksjoner, er kommandoene for å hoppe over iterasjon og spesielt å gå ut av loopen tidlig i noen tilfeller ekstremt nyttige, og det er derfor de forblir i moderne programmeringsspråk.

Nestede løkker [ | ]

Det er mulig å organisere en løkke inne i kroppen til en annen løkke. En slik syklus vil bli kalt nestet løkke... Den nestede syklusen i forhold til syklusen i kroppen den er nestet av, vil bli navngitt indre løkke, og omvendt, vil en løkke med en nestet løkke i kroppen bli navngitt utvendig i forhold til nestede. Inne i den nestede løkken kan på sin side en annen løkke nestes, og danner den neste hekkenivå etc. Antall hekkenivåer er som regel ikke begrenset.

Det totale antallet henrettelser av den indre løkkekroppen overstiger ikke produktet av antall iterasjoner av den indre og alle ytre løkkene. Hvis vi for eksempel tar tre nestede løkker, hver med 10 iterasjoner, får vi 10 kroppsutførelser for den ytre løkken, 100 for løkken på andre nivå og 1000 i den innerste løkken.

Et av problemene forbundet med nestede løkker er å organisere en tidlig utgang fra dem. Mange programmeringsspråk har en operatør for tidlig sløyfeterminering ( gå i stykker i Xi, exit i Turbo Pascal, siste i Perl, etc.), men den går vanligvis bare ut av loopen på nivået den ble kalt fra. Å kalle det fra en nestet sløyfe vil avslutte bare denne indre sløyfen, mens den ytre sløyfen vil fortsette å kjøre. Problemet kan virke langsøkt, men det oppstår noen ganger ved programmering av kompleks databehandling, når en algoritme krever et øyeblikkelig avbrudd under visse forhold, hvis tilstedeværelse kun kan kontrolleres i en dypt nestet sløyfe.

Det er flere løsninger på problemet med å gå ut av nestede løkker.

Løkker med flere bevoktede greiner[ | ]

Dijkstra syklus [ | ]

I programmeringsteori er det en annen, fundamentalt forskjellig fra den "klassiske" formen for en syklisk konstruksjon, kalt "Dijkstras syklus", oppkalt etter Edsger Dijkstra, som først beskrev den. I den klassiske Dijkstra-beskrivelsen ser en slik syklus slik ut:

Gjør P 1 → S 1,... P n → S n od

Her er markøren for begynnelsen av løkkekonstruksjonen, od er markøren for slutten av løkkekonstruksjonen, P i - Jeg-e beskyttende tilstand(et logisk uttrykk som kan ha verdien "true" eller "false"), S i - Jeg-Jeg er bevoktet lag... En syklus består av en eller flere grener(beskyttede uttrykk), som hver er et par av voktertilstanden (eller kort sagt "vakt") og det bevoktede laget (forståelig nok kan laget være komplekst i virkeligheten).

Når Dijkstra-syklusen utføres, beregnes vaktforholdene i hver iterasjon. Hvis minst én av dem er sann, utføres den korresponderende bevoktede kommandoen, hvoretter en ny iterasjon begynner (hvis flere vaktbetingelser er sanne, utføres kun én bevoktet kommando). Hvis alle beskyttelsesforhold er falske, avsluttes syklusen. Det er lett å se at Dijkstras syklus med én vakttilstand og én bevoktet kommando faktisk er en vanlig syklus med en forutsetning ("bye"-syklus).

Selv om Dijkstra-syklusen ble oppfunnet på 1970-tallet, inneholder ikke programmeringsspråk spesielle konstruksjoner for å lage den. Det eneste unntaket var det nylig opprettede Oberon-07, det første virkelige programmeringsspråket som eksplisitt støtter en loop med flere bevoktede grener. Imidlertid kan Dijkstras løkke modelleres uten store problemer ved å bruke tradisjonelle strukturer av strukturelle programmeringsspråk. Her er et eksempel på implementeringen på en av de mulige måtene på Ada-språket:

sløyfe hvis P1 så S1; ... elsif Pn deretter Sn; annet avslutte; slutt om; endeløkke;

Her er P1-Pn vaktforhold og S1-Sn er de tilsvarende bevoktede kommandoene.

Dijkstras loop er nyttig for noen spesifikke repeterende beregninger som er vanskelige å beskrive ved å bruke mer tradisjonelle looping-konstruksjoner. For eksempel representerer denne syklusen naturlig en begrenset automat - hver gren tilsvarer én tilstand av automaten, de beskyttede forholdene er konstruert slik at i den gjeldende iterasjonen velges grenen som tilsvarer den nåværende tilstanden til automaten, og koden til beskyttet kommando sikrer at beregninger utføres i gjeldende tilstand og overgang til neste (dvs. en slik endring i variabler, hvoretter, ved neste iterasjon, vil vakttilstanden til den ønskede grenen være sann).

Edderkopp syklus [ | ]

Det er lett å se at Dijkstras syklus ikke inneholder en eksplisitt fortsettelses- eller exitbetingelse, som ikke anses som en velsignelse av alle programmeringsteoretikere. Derfor ble det foreslått en komplisert konstruksjon av Dijkstra-syklusen, som ble kalt "edderkoppsyklusen". I samme notasjon ser det slik ut:

Gjør P 1 → S 1,... P n → S n ut Q 1 → T 1,... Q n → T n annet E od

Her, etter utmarkøren, har vi lagt til oppsigelsesgrener bestående av utgangsbetingelser Q i og fullføringskommandoer Ti. I tillegg lagt til en alternativ fullføring else gren med E-kommandoen.

Edderkoppløkken går slik:

• Sikringsforhold er beregnet. Hvis en sann vakttilstand eksisterer, utføres den tilsvarende bevoktede kommandoen.
• Utgangsforholdene er beregnet. Hvis en sann avslutningstilstand eksisterer, utføres den tilsvarende avslutningskommandoen, og deretter avsluttes løkkekjøringen. Hvis alle utgangsbetingelsene er falske, begynner neste iterasjon, men bare hvis minst én av vaktbetingelsene var sann i gjeldende iterasjon.
• Hvis alle vaktforhold og alle utgangsforhold i denne iterasjonen viste seg å være falske, utføres den alternative fullføringskommandoen E, hvoretter utførelsen av løkken avbrytes.

Strukturen til "edderkopp" -syklusen lar deg meget strengt beskrive betingelsene for utførelse av syklusen. I henhold til de teoretiske bestemmelsene skal den alternative termineringsgrenen ikke brukes som et av alternativene for riktig avslutning av syklusen (alle slike alternativer bør formaliseres i form av de tilsvarende termineringsgrenene med en eksplisitt betingelse), den tjener bare å spore situasjonen da for noen så av en eller annen grunn begynte syklusen å gå unormalt. Det vil si at den alternative fullføringskommandoen bare kan analysere årsakene til feilen og presentere analyseresultatene.

Selv om det ikke er noen eksplisitt syntaksstøtte for denne løkken i noe programmeringsspråk, kan en edderkoppløkke, som Dijkstras løkke, modelleres ved hjelp av tradisjonelle strukturelle konstruksjoner.

Løkkeoptimaliseringsteknikker[ | ]