For sløjfe

For - løkken er en kontrolstruktur i programmering, hvor det maksimale antal iterationer kan angives på forhånd.

Loop-elementer

${\color {Sepia}{\mathit {for}}}\;{\color {OliveGreen}{\mathit {i}}}\;{\color {BlåViolet}{\mathit {\gets }}} \;{\color {OliveGreen}{\mathit {x}}}\;{\color {Sepia}{\mathit {indtil}}}\;{\color {OliveGreen}{\mathit {n}}}\; {\color {Sepia}{\mathit {a\;increments\;of}}}\;{\color {OliveGreen}{\mathit {s}}}\;{\color {Sepia}{\mathit {make} }}$
${\color {BlåViolet}{\mathit {instruktioner}}}$

${\color {Sepia}{\mathit {end\;for}}}$

Kontrolvariabel : praktisk talt et mandat pålagt ved almindelig brug er at bruge bogstavet i Iterator som en kontrolvariabel, eller dens efterfølgere i tilfælde af indlejrede sløjfer. Brugen af dette kryptiske brev, måske ved første øjekast, er dog en glimrende måde at tilføje læsbarhed til koden på grund af dens omfattende brug. Da indlejrede sløjfer sjældent overstiger tre dimensioner (for et simpelt spørgsmål om eksponentiel eksplosion), er bogstaverne i, j og k normalt de eneste, der er involveret i denne brug. I C er det defineret i den første parameter i sætningen sammen med initialiseringen (valgfrit).

Initialisering af kontrolvariablen : i pseudolage anmodes det om at gøre det eksplicit (det er sektionen := InitialValue ), men andre mere tilladelige sprog som C kræver det ikke på en obligatorisk måde. Praksis med at bruge kontrolvariabler, der ikke initialiseres i løkken, anbefales dog ikke for kodelæsbarhed. I C er det defineret i den første parameter i sløjfen sammen med kontrolvariablen.

Kontrolbetingelse : i pseudosprog er det repræsenteret af den endelige værdi, som kontrolvariablen kan tage ( A FinalValue- afsnittet ). I C er det den anden parameter og kan være en hvilken som helst betingelse (kontrolvariablen er ikke engang påkrævet, selvom dette igen ikke anses for god praksis).

Increment : i pseudolage tages værdien 1 som standard, selvom den kan gøres eksplicit ved hjælp af sætningen PASO = ValorPaso ethvert heltal (læs godt heltal, det vil sige teknisk set kan vi dekrementere). I C er det den sidste parameter.

Brødtekst : det er, hvad der vil blive gjort i hver iteration, det kan være en eller flere instruktioner. I pseudosprog er der begrænsningen af ikke at kunne ændre værdien af kontrolvariablen; dette er ikke påkrævet i C, men anses ikke for god praksis.

Bruger

Dens hovedanvendelse er orienteret mod vektorer , idet den er i stand til at ændre, tilføje, slette eller konsultere data fundet i henhold til indekset. For sidstnævnte er en minimumsbetingelse for vektoren, at den skal bestilles, for hvis et forsøg på at læse ikke-eksisterende data, genererer dette en programmeringsfejl .

På pseudosprog

Den væsentligste forskel mellem en FOR-løkke og WHILE AND REPEAT-løkker er, at det i begyndelsen af løkken kan bestemmes, hvor mange gange løkken vil iterere, hvilket ofte kan føre til kodeoptimering af compilere. Betingelser udgør sammen med sløjfer søjlerne i struktureret programmering , og deres brug er en udvikling af en assemblersprog- sætning , der udførte den næste linje eller ej, afhængigt af værdien af en betingelse.

FOR-løkken er blevet den mest udbredte løkke i programmering, da de fleste endebetingelser med udviklingen af sprog

Det er det samme at sige:

FOR i=0 til NumberRecords(tabel) - 1, TRIN = 1
 NextRecord(tabel)
 Gør Noget(Nuværende Vare(tabel))
SLUT FOR

En anden almindelig anvendelse er at bruge FOR-løkker til at krydse vektorer med to eller flere dimensioner, i hvilket tilfælde disse iterationer er indlejret.

PSEUDO SPROG

Vektor a[3][4][2]. // Vi angiver en vektor med 3 dimensioner og 24 elementer i alt.
FOR i:= 0 TIL 2 GØR
  FOR j:= 0 TIL 3 GØR
    FOR k:= 0 TIL 1 GØR
      Gør Noget(a[i][j][k])
    SLUT FOR
  SLUT FOR
SLUT FOR

Pseudokode eksempel

For ControlVariable := StartValue TO EndValue, STEP = Increment

  Instruktioner
SLUT For

hvor ControlVariable , StartValue , EndValue og Step er heltal. Udsagn(erne) i brødteksten vil blive udført (EndValue - InitialValue + 1) gange, det vil sige, den går fra InitialValue til EndValue inklusive.

Eksempel i C++

#include <iostream>
#include <kegle.h>
bruger navneområde std;

intmain(){
   int vektor[10];
   for(int i=0; i<10; i++){
      vektor[i] = i;
      cout<<i<<endl;
   }  
   system("PAUSE");
   returnere 0;
}

I for -definitionen har vi, at kontrolvariablen i initialiseres til en værdi på 0, så er den kontrolbetingelse, der skal være falsk under dens udførelse, givet, for at fuldføre sløjfen; og endelig har vi inkrementeren i en enhed.

Hvis vi for eksempel i tilstanden sætter i < 11, vil for-løkken blive udført fra [0...10], som, når man forsøger at få adgang til elementvektoren[10], vil generere en fejl, da vektor (per definition ) går fra [0..(n-1)].

Enhver af komponenterne i parentes kan udelades, men semikolon-separatorerne skal altid vises. Resultatet er en uendelig løkke.

Eksempel ovenfor skrevet i leksikon

opgave
{
vektor[10] objekter, i er mængder
varierende i fra 0 til 9 do
         kopier i til vektor[i]
}

For hver sløjfe

Denne loop er en videreudvikling af For loop-konceptet på nogle sprog. Det bruges til at krydse gentagne datastrukturer på en enklere og mere smidig måde. For Hver-løkken kan beskrives generisk (på pseudosprog) som følger:

FOR HVER element AF type IN sæt DO
  Legeme
SLUT FOR HVER

Element : er navnet på den variabel eller objekt, der tager det itererede element i løkkens krop.
Datatype : det er typen af variabel eller den klasse, som objektet, der skal itereres, tilhører.
Set : er den datastruktur, som du vil iterere over. Den mest typiske brug er med vektorer eller -i objektorienteret programmering- klasser af typen Collection.
Brødtekst : det er, hvad der vil blive gjort i hver iteration, det kan være en eller flere instruktioner. Selvom der ikke er pålagt nogen forpligtelse i denne henseende, er det mest almindelige, at der i dette organ er en operation på det itererede element.

En af de vigtige egenskaber ved computere, der kan udnyttes, er netop deres evne til at gentage udførelsen af sekvenser af instruktioner med høj hastighed og med en høj grad af pålidelighed. Til disse formål er iterative kontrolstrukturer præcist defineret i programmeringssprog. Formålet med disse strukturer er at tillade udtryk for gentagelsen af en sekvens af instruktioner, disse strukturer kaldes cyklus, loop eller loop.

Opsummering 1 Iterative kontrolstrukturer 2 The while-sætning 3 Do/while-sætningen 4 For-kontrolstrukturen 5 Casestudie 5.1 GCF() 5.2 QtyDigits() 5.3 Faktoriel() 6 Nested Loops 7 Kilder Iterative kontrolstrukturer i livet På daglig basis, der er situationer, der ofte løses ved at udføre en bestemt rækkefølge af trin, som kan gentages mange gange, for eksempel:

Processen følger vi for at spise, mens maden ikke er færdig. Processen med at indsætte mønter, indtil det nødvendige beløb er betalt. De operationer, vi udfører for at ringe via telefon, mens kommunikation ikke opnås. Som det kan ses, er der tale om algoritmer, der udføres på daglig basis, men de har den ejendommelighed, at udførelsen af nogle af deres trin kan gentages mange gange, så længe det fastsatte mål ikke nås. Denne type algoritme er kendt som iterative eller gentagne algoritmer. I C# giver while, do/while og for sætninger dig mulighed for at udføre iterationer, loops eller cyklusser. I hvert tilfælde udføres en blok af instruktioner, mens den betingelse, der evalueres, er sand. Det fremhæves, at enhver af de 3 instruktioner opfylder det samme formål, som er at udføre en sekvens af trin, mere end én gang.

while-sætningen while-sætningen har følgende syntaks:

WhileStatement.JPG

Udsagnets semantik er som følger:

<tilstand>. Det er repræsenteret af et boolesk udtryk, og så længe det er opfyldt, vil cyklussen blive udført. [Instruktionsblok] Instruktionsblokken kan bestå af en eller flere instruktioner og er det sæt af trin, der vil blive udført i hver iteration af cyklussen. For en bedre forståelse er dens repræsentation vist i et aktivitetsdiagram.

DiagramWhile.JPG

Denne kontrolstruktur tillader gentagelse eller iteration af [Block of Instructions], mens betingelsen er sand, eller med andre ord, disse iterationer vil ende, når betingelsen er falsk, og derefter kan den næste instruktion efter et stykke tid udføres.

Det er gyldigt at påpege, at tilstanden i denne instruktion evalueres i begyndelsen af cyklussen, så hvis den første gang, tilstanden evalueres, er den falsk, vil cyklussen ikke blive udført.

Do/while-sætningen Do/while-kontrolstrukturen er en anden iterationssætning, hvor betingelsen evalueres for første gang efter at [Statement Block] er blevet eksekveret og har følgende syntaks:

DoWhileStatement.JPG

Dens semantik er den samme som while-sætningen, og dens repræsentation i et aktivitetsdiagram er som følger:

DiagramDoWhile.JPG

I denne gentagne struktur udføres sætningsblokken altid mindst én gang, fordi betingelsen evalueres sidst. Når først evalueringen er udført, hvis resultatet er sandt, udføres [Instruktionsblokken] igen, ellers udføres de følgende instruktioner og afslutter cyklussen. Funktionaliteten af denne metode vil være den samme som i while-eksemplet. Den eneste forskel er måden løkken styres på. I praksis vil du opleve, at while-sætningen bruges oftere end gør – mens-sætningen. At vælge den ene instruktion frem for den anden er et personligt valg. Et meget vigtigt aspekt at huske på i betingede sløjfer er behovet for at overveje mindst én instruktionsblok i instruktionsblokken, som på en eller anden måde ændrer – på et tidspunkt – resultatet af det boolske udtryk. Forklaringen er ganske enkelt givet ved, at hvis denne instruktion ikke eksisterede, når løkken blev indtastet, ville den aldrig ende, så den ville falde ind i en uendelig løkke.

Kontrolstrukturen for De iterative processer, som vi hidtil har set, ender med en betingelse. I mange situationer udføres iterationerne et vist antal gange, mange forfattere kalder dem cyklusser ved at tælle, fordi det på forhånd er kendt, hvor mange gange processen, der gentages, vil blive udført. I denne type iteration er der altid brug for en variabel for at holde styr på, hvor mange gange processen gentages, hvorfor de også er kendt som cyklusser med en kontrolvariabel. En af de bedst kendte og mest brugte cyklusser i de fleste programmeringssprog er for-sætningen, som normalt styres af en tæller eller kontrolvariabel og har følgende syntaks:

InstructionFor.JPG

Udsagnets semantik er som følger:

<vejledning 1>. Det vil kun blive udført én gang i begyndelsen af cyklussen, initialiseringer og variabeldeklarationer udføres normalt, da det, som tidligere nævnt, kun udføres én gang. Hvis du ønsker at udføre eller udføre mere end én instruktion på dette tidspunkt, skal disse instruktioner adskilles med kommaer ("."). <udtryk>. Det evalueres i hver iteration, og afhængigt af den værdi, det returnerer, vil det afhænge af, om cyklussen fortsætter med at udføre (udtryksværdi sand) eller ej (falsk). Bemærk, at hvis intet er placeret i denne del, vil cyklussen tage værdien af udtrykket som sand, så i princippet kan cyklussen gentages uendeligt. <vejledning 2>. Den udføres altid i hver cyklus ved afslutningen af udførelsen af alle de instruktioner, der hører til den pågældende for-løkke. Det kan normalt indeholde nogle opdateringer til kontrolvariablerne. Analogt med <instruktion 1>, hvis du ønsker at udføre mere end én instruktion på dette tidspunkt, skal de adskilles med kommaer. Bemærk, at det er obligatorisk at adskille hvert led, der udgør for-sætningen, ved at bruge et semikolon (;), ellers vil compileren vise en semantisk typefejl. Gentag, at <instruktion 1> kun udføres én gang i begyndelsen, at <instruktion 2> er den, der generelt bruges til at ændre kontrolvariablen, selvom den også kan modificeres i løkken, og at <udtryk> er den, der garanterer cyklussens endelighed, vil for blive udført, så længe <udtryk> evalueres og tager værdien sand.

Se også

Referencer

Eksterne links

for loop i C++. Struktur, syntaks og brug af en for-løkke i C++