For loop

De for loop is een besturingsstructuur in het programmeren waarin vooraf het maximale aantal iteraties kan worden aangegeven.

Luselementen

${\color {Sepia}{\mathit {for}}}\;{\color {OliveGreen}{\mathit {i}}}\;{\color {BlueViolet}{\mathit {\gets }}} \;{\color {OliveGreen}{\mathit {x}}}\;{\color {Sepia}{\mathit {tot}}}\;{\color {OliveGreen}{\mathit {n}}}\; {\color {Sepia}{\mathit {a\;increments\;of}}}\;{\color {OliveGreen}{\mathit {s}}}\;{\color {Sepia}{\mathit {make} }}$
${\color {BlueViolet}{\mathit {instructies}}}$

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

Regelvariabele : praktisch een mandaat dat door algemeen gebruik wordt opgelegd, is om de letter i Iterator als regelvariabele te gebruiken, of zijn opvolgers in het geval van geneste lussen. Het gebruik van deze cryptische letter, misschien op het eerste gezicht, is echter een uitstekende manier om de code leesbaarder te maken vanwege het uitgebreide gebruik ervan. Aangezien geneste lussen zelden drie dimensies overschrijden (voor een simpele kwestie van exponentiële explosie), zijn de letters i, j en k meestal de enige die bij dit gebruik betrokken zijn. In C wordt het gedefinieerd in de eerste parameter van de instructie samen met de initialisatie (optioneel).

Initialisatie van de controlevariabele : in pseudotaal wordt gevraagd om deze expliciet te maken (het is de sectie := InitialValue ), maar andere, meer permissieve talen zoals C vereisen dit niet op een verplichte manier. Het gebruik van controlevariabelen die niet in de lus zijn geïnitialiseerd, wordt echter niet aanbevolen voor de leesbaarheid van de code. In C wordt het gedefinieerd in de eerste parameter van de lus samen met de regelvariabele.

Controlevoorwaarde : in pseudotaal wordt het weergegeven door de uiteindelijke waarde die de controlevariabele kan aannemen (de A FinalValue- sectie ). In C is het de tweede parameter en kan elke voorwaarde zijn (de controlevariabele is niet eens vereist, hoewel dit opnieuw niet als een goede praktijk wordt beschouwd).

Increment : in pseudotaal wordt standaard de waarde 1 genomen, hoewel deze expliciet kan worden gemaakt door middel van de zin PASO = ValorPaso any integer (lees goed integer, dat wil zeggen, technisch gezien kunnen we decrementeren). In C is het de laatste parameter.

Body : dit is wat er in elke iteratie wordt gedaan, het kunnen een of meer instructies zijn. In pseudotaal is er de beperking van het niet kunnen wijzigen van de waarde van de controlevariabele; dit is niet vereist in C, maar wordt niet als een goede praktijk beschouwd.

Gebruikt

Het belangrijkste gebruik ervan is gericht op vectoren , het kunnen wijzigen, toevoegen, verwijderen of raadplegen van gegevens die zijn gevonden volgens de index. Voor dat laatste is een minimumvoorwaarde van de vector dat deze geordend moet worden, want als een poging wordt gedaan om niet-bestaande data uit te lezen, genereert dit een programmeerfout .

In

Het belangrijkste verschil tussen een FOR-lus en WHILE AND REPEAT-lussen is dat aan het begin van de lus kan worden bepaald hoe vaak de lus zal herhalen, wat vaak kan leiden tot code-optimalisatie door compilers. Conditionals, samen met lussen, vormen de pijlers van gestructureerd programmeren en hun gebruik is een evolutie van een assembleertaalstatement dat de volgende regel al dan niet uitvoerde, afhankelijk van de waarde van een voorwaarde.

De FOR-lus is de meest gebruikte lus in het programmeren geworden, omdat met de evolutie van talen de meeste eindvoorwaarden

Het is hetzelfde om te zeggen:

VOOR i=0 naar NumberRecords (tabel) - 1, STAP = 1
 VolgendeRecord(tabel)
 Iets doen (huidig item (tabel))
EINDE VOOR

Een ander veelgebruikt gebruik is het gebruik van FOR-lussen om vectoren van twee of meer dimensies te doorkruisen, in welk geval deze iteraties genest zijn.

PSEUDO-TAAL

Vectora[3][4][2]. // We geven een vector aan van 3 dimensies en in totaal 24 elementen.
VOOR i:= 0 TOT 2 DO
  VOOR j:= 0 TOT 3 DO
    VOOR k:= 0 TOT 1 DO
      Doe Iets (a[i][j][k])
    EINDE VOOR
  EINDE VOOR
EINDE VOOR

Pseudocode voorbeeld

Voor ControlVariable: = StartValue TO EndValue, STEP = Increment

  instructies:
EINDE Voor

waarbij ControlVariable , StartValue , EndValue en Step gehele getallen zijn. De instructie(s) in de hoofdtekst worden (EndValue - InitialValue + 1) keer uitgevoerd, dat wil zeggen, het gaat van InitialValue naar EndValue inclusief.

Voorbeeld in C++

#include <iostream>
#include <cone.h>
namespace std; gebruiken;

intmain(){
   int-vector[10];
   for(int i=0; i<10; i++){
      vector[i] = ik;
      cout<<i<<endl;
   }  
   systeem ("PAUZE");
   retourneer 0;
}

In de for -definitie hebben we dat de controlevariabele i wordt geïnitialiseerd op een waarde van 0, waarna de controlevoorwaarde wordt gegeven die tijdens de uitvoering onwaar moet zijn, om de lus te voltooien; en tot slot hebben we de incrementer in een eenheid.

Als we bijvoorbeeld in de voorwaarde i < 11 plaatsen, dan wordt de for-lus uitgevoerd vanaf [0...10], die bij het proberen toegang te krijgen tot de elementvector [10] een fout zal genereren, aangezien de vector (per definitie ) gaat van [0..(n-1)].

Elk van de componenten tussen haakjes kan worden weggelaten, maar de puntkommascheidingstekens moeten altijd worden weergegeven. Het resultaat is een oneindige lus.

Voorbeeld hierboven geschreven in lexicon

taak
{
vector[10] objecten, ik ben hoeveelheden
variërend i van 0 tot 9 do
         kopieer i naar vector[i]
}

Voor elke lus

Deze lus is een evolutie van het For-lusconcept in sommige talen. Het wordt gebruikt om repetitieve datastructuren op een eenvoudigere en flexibelere manier te doorkruisen. De For Each-lus kan als volgt generiek (in pseudotaal) worden beschreven:

VOOR ELK element VAN type IN set DO
  Lichaam
EINDE VOOR ELKE

Element : is de naam van de variabele of het object dat het herhaalde element in de hoofdtekst van de lus neemt.
Gegevenstype : het is het type variabele of de klasse waartoe het te herhalen object behoort.
Set : is de gegevensstructuur die u wilt herhalen. Het meest typische gebruik is met vectoren of -in objectgeoriënteerde programmering- klassen van het type Collection.
Body : dit is wat er in elke iteratie wordt gedaan, het kunnen een of meer instructies zijn. Hoewel er in dit opzicht geen verplichting wordt opgelegd, is de meest voorkomende dat er in deze Body enige bewerking wordt uitgevoerd op het herhaalde element.

Een van de belangrijke eigenschappen van computers die kunnen worden misbruikt, is juist hun vermogen om de uitvoering van reeksen instructies met hoge snelheid en met een hoge mate van betrouwbaarheid te herhalen. Voor deze doeleinden worden iteratieve besturingsstructuren nauwkeurig gedefinieerd in programmeertalen. Het doel van deze structuren is om de herhaling van een reeks instructies mogelijk te maken, deze structuren worden cyclus, lus of lus genoemd.

Samenvatting 1 Iteratieve controlestructuren 2 Het while-statement 3 Het do/while-statement 4 De for-controlestructuur 5 Casestudy 5.1 GCF() 5.2 QtyDigits() 5.3 Factorial() 6 Geneste lussen 7 Bronnen Iteratieve controlestructuren in het leven Op een dagelijkse basis, er zijn situaties die vaak worden opgelost door een bepaalde reeks stappen uit te voeren die vele malen kunnen worden herhaald, bijvoorbeeld:

Het proces dat we volgen om te eten, terwijl het eten nog niet klaar is. Het proces van het inbrengen van munten, totdat het benodigde bedrag is betaald. De handelingen die wij uitvoeren zijn telefonisch te bellen, terwijl communicatie niet tot stand komt. Zoals te zien is, zijn dit algoritmen die dagelijks worden uitgevoerd, maar ze hebben de bijzonderheid dat de uitvoering van sommige van hun stappen vele malen kan worden herhaald, zolang het gestelde doel niet wordt bereikt. Dit type algoritme staat bekend als iteratieve of repetitieve algoritmen. In C# kunt u met de while-, do/while- en for-statements iteraties, lussen of cycli uitvoeren. In elk geval wordt een blok instructies uitgevoerd terwijl de voorwaarde die wordt geëvalueerd waar is. Er wordt benadrukt dat elk van de 3 instructies hetzelfde doel vervult, namelijk het meer dan eens uitvoeren van een reeks stappen.

Het while-statement Het while-statement heeft de volgende syntaxis:

WhileStatement.JPG

De semantiek van de verklaring is als volgt:

<conditie>. Het wordt weergegeven door een Booleaanse uitdrukking en zolang deze is vervuld, wordt de cyclus uitgevoerd. [Instructieblok] Het instructieblok kan bestaan uit een of meerdere instructies en is de reeks stappen die in elke iteratie van de cyclus worden uitgevoerd. Voor een beter begrip wordt de weergave ervan weergegeven in een activiteitendiagram.

DiagramWhile.JPG

Deze controlestructuur maakt het mogelijk om het [Blok van instructies] te herhalen of te herhalen terwijl de voorwaarde waar is, of met andere woorden, deze herhalingen zullen eindigen wanneer de voorwaarde onwaar is en dan kan de volgende instructie na de tijd worden uitgevoerd.

Het is geldig om erop te wijzen dat in deze instructie de voorwaarde wordt geëvalueerd aan het begin van de cyclus, dus als de eerste keer dat de voorwaarde wordt geëvalueerd, deze onjuist is, zal de cyclus niet worden uitgevoerd.

De do/while-instructie De do/while-besturingsstructuur is een andere iteratie-instructie waarin de voorwaarde voor de eerste keer wordt geëvalueerd nadat het [Statement Block] is uitgevoerd en heeft de volgende syntaxis:

DoWhileStatement.JPG

De semantiek is dezelfde als die van het while-statement en de weergave ervan in een activiteitendiagram is als volgt:

DiagramDoWhile.JPG

In deze repetitieve structuur wordt het instructieblok altijd minstens één keer uitgevoerd omdat de voorwaarde als laatste wordt geëvalueerd. Als de evaluatie eenmaal is uitgevoerd en het resultaat waar is, wordt het [Instructieblok] opnieuw uitgevoerd, anders worden de volgende instructies uitgevoerd en wordt de cyclus verlaten. De functionaliteit van deze methode is hetzelfde als in het while-voorbeeld. Het enige verschil is de manier waarop de lus wordt bestuurd. In de praktijk zul je merken dat het while-statement vaker wordt gebruikt dan het do – while-statement. Het kiezen van de ene instructie boven de andere is een persoonlijke keuze. Een zeer belangrijk aspect om in gedachten te houden in conditionele lussen is de noodzaak om ten minste één instructieblok binnen het instructieblok te overwegen, dat op de een of andere manier – op een bepaald moment – het resultaat van de Booleaanse expressie verandert. De verklaring wordt eenvoudigweg gegeven door het feit dat als deze instructie niet zou bestaan als de lus eenmaal was ingevoerd, deze nooit zou eindigen en dus in een oneindige lus zou vallen.

De controlestructuur voor De iteratieve processen die we tot nu toe hebben gezien, eindigen met een voorwaarde. In veel situaties worden de iteraties een bepaald aantal keren uitgevoerd, veel auteurs noemen ze cycli door te tellen omdat van tevoren bekend is hoe vaak het herhaalde proces zal worden uitgevoerd. Bij dit type iteratie is altijd een variabele nodig om bij te houden hoe vaak het proces wordt herhaald, daarom worden ze ook wel cycli met een controlevariabele genoemd. Een van de bekendste en meest gebruikte cycli in de meeste programmeertalen is het for-statement, dat meestal wordt bestuurd door een teller of controlevariabele en de volgende syntaxis heeft:

InstructieVoor.JPG

De semantiek van de verklaring is als volgt:

<instructies 1>. Het wordt slechts één keer uitgevoerd aan het begin van de cyclus, initialisaties en variabele declaraties worden meestal uitgevoerd omdat, zoals eerder vermeld, het slechts één keer wordt uitgevoerd. Als u op dit moment meer dan één instructie wilt uitvoeren of uitvoeren, moeten deze instructies worden gescheiden door komma's ("."). <uitdrukking>. Het wordt geëvalueerd in elke iteratie en afhankelijk van de waarde die het retourneert, hangt het ervan af of de cyclus doorgaat met uitvoeren (expressiewaarde waar) of niet (onwaar). Merk op dat als er niets in dit deel wordt geplaatst, de cyclus de waarde van de uitdrukking als waar zal aannemen, dus in principe kan de cyclus oneindig worden herhaald. <instructies 2>. Het wordt altijd uitgevoerd in elke cyclus aan het einde van het uitvoeren van alle instructies die bij de for-lus in kwestie horen. Het kan meestal een update voor de controlevariabelen bevatten. Analoog aan <instructies 1>, als u meer dan één instructie op dit moment wilt uitvoeren, moeten deze worden gescheiden door komma's. Merk op dat het verplicht is om elke term die deel uitmaakt van de for-instructie te scheiden door een puntkomma (;) te gebruiken, anders zal de compiler een semantische typefout weergeven. Herhaal dat <instructie 1> slechts één keer aan het begin wordt uitgevoerd, dat <instructie 2> degene is die over het algemeen wordt gebruikt om de regelvariabele te wijzigen, hoewel deze ook in de lus kan worden gewijzigd, en dat <expressie> de garantie is dat de eindigheid van de cyclus, de for wordt uitgevoerd zolang <expression> wordt geëvalueerd en de waarde true aanneemt.

Zie ook

Referenties

Externe links

for-lus in C++. Structuur, syntaxis en gebruik van een for-lus in C++