Loop-operators in C Sharp. for, while en do while-lussen in C

Eigenlijk het resultaat van het programma:

0 1 2 3 4 5 6 7 8 9

Dit programma is een heel eenvoudig voorbeeld van het gebruik van een lus. variabele i krijgt nul toegewezen, en terwijl i kleiner is dan 10, wordt de waarde van variabele i op het scherm afgedrukt, waarna er één wordt toegevoegd aan variabele i en alles opnieuw wordt herhaald totdat de voorwaarde onwaar wordt. Houd er rekening mee dat de waarde van de variabele i wordt verhoogd nadat de code in de hoofdtekst van de lus voor de eerste keer wordt uitgevoerd.

De while-lus is een heel eenvoudige lus, hier is de structuur:

While (/*condition*/) ( // body van de lus - hier is de code die herhaald moet worden)

Het lichaam van de lus wordt uitgevoerd als de lusvoorwaarde waar is. De voorwaarde is een Booleaanse expressie, zoals x == 1 of x! = 7 (x is niet gelijk aan 7). Dat wil zeggen, de voorwaarde kan absoluut alles zijn: elke combinatie van logische uitdrukkingen. Hier is een voorbeeld van een samengestelde voorwaarde - x == 3 || x > 10 , deze voorwaarde zal waar zijn als x gelijk is aan drie of x groter is dan 10. Merk op dat hoewel het een initialisatiesectie of een sectie voor gecontroleerde variabelewijziging heeft, dus voordat u deze lus gebruikt, u eerst de variabele moet declareren die wordt getest in de conditielus en in de hoofdtekst van de lus verandert u de waarde van deze variabele. Laten we eigenlijk eens kijken naar een eenvoudig voorbeeld met behulp van een while-lus:

#erbij betrekken int main() ( int var = 0; /* zorg ervoor dat u eerst de variabele declareert */ while (var< 10) { /* пока значение переменной var меньше 10 */ printf("%d\n", var); var++; /* обновляем значение в переменной var(если этого не делать, то условие цикла всегда будет истинным, тогда цикл будет - бесконечным) */ } getchar(); }

We hebben dus naar een ander voorbeeld gekeken van het gebruik van lussen, en zoals je kunt zien, is er niets ingewikkelds in dit voorbeeld. Stel je voor dat de lus altijd de code begint te herhalen die zich in de hoofdtekst van de lus bevindt. Zodra geëxecuteerd laatste exploitant in de body van de lus wordt de lusvoorwaarde gecontroleerd. Als de voorwaarde nog steeds waar is, blijft de lus werken, en als de voorwaarde onwaar is, wordt de lus verlaten.

Er is een ander type lus: doe while. Deze lus is handig wanneer u code moet uitvoeren volgens ten minste- 1 keer. Laten we eens kijken naar de structuur:

Doen ( // loop body ) while (/*condition*/);

De structuur is heel eenvoudig: zoals u kunt zien, bevindt de voorwaarde zich aan het einde van de lus en dienovereenkomstig zal de voorwaarde worden gecontroleerd nadat de code in de hoofdtekst van de lus is uitgevoerd. Houd er rekening mee dat de voorwaarde aan het einde van de lus wordt getest en niet aan het begin. Het codeblok in de hoofdtekst van de lus wordt dus minstens één keer uitgevoerd. Als de voorwaarde waar is, springt de lus terug naar het begin en voert deze opnieuw uit. Een do while-lus is bijna hetzelfde als een while-lus, behalve dat de body van de lus gegarandeerd minstens één keer wordt uitgevoerd. De while-lus controleert eerst de voorwaarde en voert vervolgens het codeblok in de body uit, als de voorwaarde uiteraard waar is, terwijl de do while-lus eerst de code in de body van de lus uitvoert en vervolgens de voorwaarde controleert, en of deze klopt, dan blijft het lopen. Hieronder ziet u een voorbeeld van de do while-lus:

#erbij betrekken int main() ( int i = 0; do ( /* Drukt een bericht af en sluit af */ printf("Hallo! Ik ben bezig met een while-lus\n"); ) while (i != 0); getchar() ;)

Let op de puntkomma aan het einde van de lus, deze moet u altijd plaatsen zoals in het bovenstaande voorbeeld. Heel vaak wordt deze puntkomma niet opgenomen, wat resulteert in een compilatiefout. Alleen deze lus eindigt met een puntkomma; de rest van de lussen heeft niets aan het einde, behalve het afsluitende haakje. Merk op dat in het bovenstaande voorbeeld deze lus één keer wordt uitgevoerd omdat het bericht eerst wordt afgedrukt en vervolgens de toestand van de lus wordt gecontroleerd.

Loop-operator voor generaliseert de bekende cyclusconstructie van het rekenkundige progressietype. De syntaxis is:

voor(initializers; condition; expression_list) operator

De verklaring na het haakje sluiten definieert het lichaam van de lus. In de meeste gevallen is het lichaam van de lus een blok. Initialisatoren stellen de beginwaarde van een of meer variabelen in, vaak tellers of eenvoudigweg lusvariabelen genoemd. De voorwaarde specificeert de voorwaarde voor het beëindigen van de lus; de corresponderende expressie moet, indien berekend, de waarde ontvangen WAAR of vals. Een door komma's gescheiden lijst met expressies laat zien hoe de lustellers bij elke uitvoeringsstap veranderen. Als de lusvoorwaarde waar is, wordt de hoofdtekst van de lus uitgevoerd, vervolgens worden de tellerwaarden gewijzigd en wordt de voorwaarde opnieuw gecontroleerd. Zodra de voorwaarde onwaar wordt, eindigt de lus. In een normale situatie wordt het lichaam van de lus een eindig aantal keren uitgevoerd. Lustellers worden vaak rechtstreeks in de initialisator gedeclareerd en zijn dienovereenkomstig variabelen die in de lus zijn gelokaliseerd.

In gevallen waarin het mogelijk is om de lus voortijdig te beëindigen met behulp van een van de jump-instructies, worden tellers vóór de lus gedeclareerd, waardoor hun waarden kunnen worden geanalyseerd bij het verlaten van de lus.

Neem als voorbeeld het klassieke probleem of een tekstreeks een palindroom is. Om het op te lossen, de cyclus voor past het beste.

Hier worden twee tellers gebruikt: de ene stijgt, de andere daalt. Hier is de tekst van de overeenkomstige procedure:

/// < samenvatting>
/// Definitie van palindromen. Demonstratie fietsenvoor
///
/// tekst
/// < retourneert> WAAR- als de tekst een palindroom is
openbare bool Palindroom(string str){
voor (int. ik= 0, J= str.Lengte- 1; i< J; ik++, j--)
als (str[i]!= str[j]) return (false);
opbrengst (WAAR);
} // Palindroom

5.6.2. Terwijl lussen

Cyclus terwijl(uitdrukking) is een universeel type lus dat in alle programmeertalen aanwezig is. De body van de lus wordt uitgevoerd zolang de expressie waar blijft terwijl. In de C#-taal heeft dit type lus twee wijzigingen: het controleren van de voorwaarde aan het begin en aan het einde van de lus. De eerste wijziging heeft de volgende syntaxis:

while(expressie)-instructie

Deze wijziging komt overeen met een lus met een voorwaarde. De body van zo'n lus mag nooit worden uitgevoerd. In een normale situatie is elke uitvoering van het luslichaam een ​​volgende stap in de richting van het voltooien van de lus.

Een lus die de beëindigingsvoorwaarde aan het einde controleert, komt overeen met een lus met een postvoorwaarde. De body van zo'n lus wordt minstens één keer uitgevoerd. Hier is de syntaxis voor deze wijziging:

Doen
exploitant
terwijl(expressie);

Laten we een voorbeeld geven waarin beide wijzigingen van de cyclus deelnemen terwijl. In de buitenste lus wordt de controle aan het einde uitgevoerd en in de binnenste lus aan het begin. De buitenste cyclus is een typisch voorbeeld van een organisatie curricula, wanneer een bepaalde taak herhaaldelijk wordt opgelost in dialoog met de gebruiker. Bij elke stap voert de gebruiker nieuwe gegevens in, lost het probleem op en analyseert de ontvangen gegevens. Het ligt in zijn macht of hij doorgaat met de berekeningen of niet, maar hij moet het probleem minstens één keer oplossen. Binnenste lus Doenterwijl gebruikt om het reeds bekende probleem met palindromen op te lossen. Hier is de tekst van de overeenkomstige procedure:

/// < samenvatting>
/// Twee lussen: met een vinkje aan het einde en aan het begin.
/// De buitenste lus is een voorbeeld van een probleem dat vele malen kan worden opgelost.
/// Het einde van de cyclus wordt bepaald in dialoog met de gebruiker.
///
openbare leegte Loop(){
// beginproceduresstring antwoord, tekst;
Doen{
// begin van buitenste lus
Troosten. Schrijflijn("Voer een woord in");
tekst= Console.ReadLine();
int ik= 0, J= tekst.Lengte- 1;
terwijl ((ik< J)&& (tekst[ik]== tekst[j])) (
// interieurcyclus
ik++; J-- ;
}
als (tekst[i]== tekst[j]) Console.WriteLine(tekst+ " - Ditpalindroom!");
anders Console.WriteLine(text+ " - DitNietpalindroom!");
Console.WriteLine("Laten we doorgaan? (ja/nee)");
antwoord= Console.ReadLine();
} terwijl (antwoord== "Ja");// eindeexterncyclus
} // Lus

5.6.3. voor elke lus

Een nieuw type lus, niet overgenomen van C++, is de lus voorleggen, handig bij het werken met arrays, verzamelingen en andere soortgelijke gegevenscontainers. De syntaxis is:

voorleggen(type-IDincontainer) exploitant

De lus werkt precies zoals de naam doet vermoeden: de hoofdtekst van de lus wordt uitgevoerd voor elk element in de container. Het type identificatie moet consistent zijn met het type elementen dat in de gegevenscontainer is opgeslagen. Er wordt ook aangenomen dat de elementen van de container (array, collectie) geordend zijn. Bij elke stap van de cyclus ontvangt de identificatie die het huidige element van de container definieert, de waarde van het volgende element in overeenstemming met de volgorde die voor de elementen van de container is vastgesteld. De body van de lus wordt uitgevoerd met dit huidige element - het wordt net zo vaak uitgevoerd als er elementen in de container zijn. De cyclus eindigt wanneer alle elementen van de container volledig zijn opgesomd. Een serieus nadeel van cycli voorleggen in de C#-taal is dat de lus alleen werkt voor het lezen, maar niet voor het schrijven van elementen. Je moet de container dus vullen met elementen met behulp van andere lusoperatoren.

Het onderstaande voorbeeld laat zien hoe u met een 3D-array werkt. Er wordt een array gemaakt met behulp van lussen zoals voor, en bij het vinden van de som van de elementen, het minimum en maximale waarde lus wordt gebruikt voorleggen:

/// < samenvatting>
/// Demonstratie van de cyclusvoorleggen.
/// Bereken de som, maximum en minimale elementen
/// een driedimensionale array gevuld met willekeurige getallen.
///
openbare leegte SumMinMax(){
int[,] arr3d= nieuwe int;
Willekeurige rnd= nieuw Willekeurig();
voor (int. ik= 0; i< 10; ik++)
voor (int j= 0; J< 10; j++)
voor (int k= 0; k< 10; k++)
arr3d= rnd.Volgende(100);
lange som= 0;
int min= arr3d,maximaal= arr3d;
foreach (int-item in arr3d){
som+= item;
als (punt> maximaal)max= item;
anders als (art< min) min= item;
}
Console.WriteLine("som= {0}, min= {1}, maximaal= {2}", som, min, max);
} // SomMinMax

voor lussen en terwijl

C# heeft er vier verschillende soorten loops (for, while, do...while en foreach), waarmee een codeblok herhaaldelijk kan worden uitgevoerd totdat aan een bepaalde voorwaarde is voldaan. In dit artikel leren we over for- en while-lussen.

voor lus

De for-lus in C# biedt een iteratiemechanisme waarin een bepaalde voorwaarde wordt getest voordat elke iteratie wordt uitgevoerd. De syntaxis van deze verklaring wordt hieronder weergegeven:

voor (initializer; voorwaarde; iterator) statement(s)

dit is een expressie die wordt geëvalueerd vóór de eerste uitvoering van de lusbody (meestal wordt een lokale variabele geïnitialiseerd als lusteller). Initialisatie wordt doorgaans weergegeven door een toewijzingsoperator die specificeert oorspronkelijke betekenis een variabele die als teller fungeert en de lus bestuurt;

dit is een expressie die wordt getest vóór elke nieuwe iteratie van de lus (moet true retourneren voordat de volgende iteratie kan worden uitgevoerd);

een expressie die na elke iteratie wordt geëvalueerd (meestal wordt de waarde van de lusteller verhoogd).

Houd er rekening mee dat deze drie hoofddelen van de for-lus-instructie moeten worden gescheiden door een puntkomma. De for-lus blijft actief zolang de conditietest de waarde True oplevert. Zodra deze controle mislukt, eindigt de lus en wordt de programma-uitvoering voortgezet met de instructie die volgt op de for-lus.

Het is vermeldenswaard dat de for-lus ideaal is voor het herhaaldelijk uitvoeren van een instructie of een blok met instructies, een bekend aantal keren. Laten we eens kijken praktische toepassing for lus met behulp van het volgende voorbeeld:

Systeem gebruiken; met behulp van System.Collections.Generic; met behulp van System.Linq; met behulp van System.Text; naamruimte ConsoleApplication1 ( class Program ( // Deze methode drukt een tafel van vermenigvuldiging af // van grootte b x b static void tab(byte b) ( Console.WriteLine("Tafel van vermenigvuldiging (0) x (0)\n", b); // Deze lus gaat door de regels voor (int i = 1; ik

terwijl lus

gelijk aan voor, terwijl is ook een cyclus met vooraf controleren. De syntaxis is vergelijkbaar, maar terwijl lussen slechts één uitdrukking bevatten:

while(condition) operator(s);

Waar exploitant is een enkele operator of een blok operatoren, en voorwaarde betekent een specifieke cycluscontroleconditie en kan elke willekeurige zijn logische uitdrukking. In deze lus wordt de instructie uitgevoerd zolang de voorwaarde waar is. Zodra de voorwaarde onwaar wordt, wordt de programmabesturing overgedragen naar de coderegel die onmiddellijk volgt op de lus.

Net als de for-lus controleert de while-lus voorwaardelijke expressie, opgegeven aan het begin van de lus. Dit betekent dat de code in de hoofdtekst van de lus mogelijk helemaal niet wordt uitgevoerd, en elimineert ook de noodzaak om een ​​afzonderlijke controle uit te voeren vóór de lus zelf.

doe while en foreach-lussen

lus doen . . terwijl

doe... while-lus in C# is dit een versie van while met een controle achteraf. Dit betekent dat de lusvoorwaarde wordt gecontroleerd nadat de lusbody is uitgevoerd. Daarom zijn do...while-lussen nuttig in situaties waarin een blok met instructies minstens één keer moet worden uitgevoerd. Hieronder staat algemene vorm exploitant do-while-lus:

do (operatoren; ) while (voorwaarde);

Als er maar één operator is beugel Inschrijvingen op dit formulier zijn optioneel. Ze worden echter vaak gebruikt om de do-while-constructie leesbaarder te maken en niet te worden verward met de while-lusconstructie. De do-while-lus loopt zolang de voorwaardelijke expressie waar is. Een voorbeeld van het gebruik van een do-while-lus is volgende programma, die de faculteit van een getal berekent:

Systeem gebruiken; met behulp van System.Collections.Generic; met behulp van System.Linq; met behulp van System.Text; naamruimte ConsoleApplication1 ( class Program ( static void Main(string args) ( try ( // Bereken de faculteit van een getal int i, resultaat = 1, num = 1; Console.WriteLine("Voer een getal in:"); i = int .Parse(Console .ReadLine()); Console.Write("\n\nFactorial (0) = ", i);

foreach lus

foreach lus dient voor cyclische toegang tot elementen van een verzameling, een groep objecten. C# definieert verschillende soorten verzamelingen, waarvan elk een array is. Hieronder vindt u de algemene vorm van de operator foreach lus:

foreach (type loop_variable_name in collectie) instructie;

Hier typ loop_variabele_naam geeft het type en de naam aan van de lusbesturingsvariabele die bij elke stap van de foreach-lus de waarde ontvangt van het volgende element van de verzameling. En verzameling duidt een cyclisch opgevraagde verzameling aan, die hierna een array vertegenwoordigt. Daarom moet het type van de lusvariabele overeenkomen met het type van het array-element. Daarnaast kan het type worden aangegeven trefwoord var. In dit geval bepaalt de compiler het type lusvariabele op basis van het type array-element. Dit kan handig zijn bij het werken met bepaalde typen query's. Maar in de regel wordt het type expliciet gespecificeerd.

De foreach-lusinstructie werkt als volgt. Wanneer de lus start, wordt het eerste element van de array geselecteerd en toegewezen aan de lusvariabele. Bij elke volgende iteratiestap wordt het volgende array-element geselecteerd en opgeslagen in een lusvariabele. De lus eindigt wanneer alle elementen van de array zijn geselecteerd.

Met een foreach-lus kunt u elk element van een verzameling doorlopen (een object dat een lijst met andere objecten vertegenwoordigt). Technisch gezien moet iets de IEnumerable-interface ondersteunen om als een verzameling te worden beschouwd. Voorbeelden van verzamelingen zijn C#-arrays, verzamelingsklassen uit de System.Collection-naamruimte en aangepaste verzamelingsklassen.

Gigabyte zal sets aanbieden van het Z390 Aorus Xtreme WaterForce-bord en een overgeklokte Core i9-9900K. Gigabyte-bedrijf zal binnenkort kits op de markt brengen bestaande uit het Z390 Aorus Xtreme WaterForce-moederbord en overgeklokt naar 5,1 GHz Intel-processor Core i9-9900K (8 cores/16 threads, 3,6/5 GHz). Deze sets zijn voornamelijk

Samsung Galaxy De A90 werd voor het eerst getest in de Geekbench-benchmark. 10 april Samsung-bedrijf zal zijn volgende presentatie houden, waar het waarschijnlijk een aantal smartphones uit het middensegment zal presenteren prijsklasse. Onder hen zou de Samsung Galaxy A90 moeten zijn, die letterlijk net is getest

Op de website Slahsleaks, die vaak exclusieve foto's van nieuwe plaatsen plaatst mobiele apparaten en accessoires daarvoor, gepubliceerd live-foto voorpaneel Nokia-smartphone 8.1 Plus. De smartphone heeft zeer smalle frames rond de omtrek, een iets breder frame onder het scherm,

Een internationaal team van wetenschappers heeft dit aangetoond nieuwe manier het omzetten van licht dat door een conventionele laser wordt uitgezonden, in zogenaamd kwantumlicht. Het bijzondere aan dergelijk licht zijn de identieke kwantumeigenschappen van de fotonen, die door dit licht naar voren worden gebracht

In de meerderheid moderne apparaten, beginnend bij de eenvoudigste elektronisch horloge Er worden speciale componenten gebruikt, klokgeneratoren genaamd, die, wanneer er een geschikt signaal op wordt toegepast, oscillaties beginnen te produceren met een strikt gespecificeerde frequentie. Meer

Astronomen hebben 83 nieuwe superzware zwarte gaten ontdekt, waarvan de leeftijd vrijwel gelijk is aan de leeftijd van het toegankelijke deel van het heelal. De identificatie van deze zwarte gaten en de bepaling van hun parameters werd uitgevoerd door hun helderheid en emissiespectrum te analyseren. Zij

Google heeft aangekondigd nieuwe functie om e-mails naar Gmail te verzenden. Nu kunnen ze worden gepland om op een geschikt tijdstip te worden verzonden. Om een ​​brief in te plannen, klikt u op de pijl naast de knop "Verzenden" en selecteert u juiste tijd en de datum van verzending, schrijft Chronicle.info met verwijzing naar

iFixit-specialisten bestudeerden het ontwerp van de tablet iPad-computer mini nieuwe generatie, die Apple-bedrijf vorige maand officieel onthuld. Laten we u eraan herinneren dat het apparaat is uitgerust Retina-display met een diagonaal van 7,9 inch. De resolutie is 2048 × 1536 pixels,

Vizio-tv's en -schermen krijgen AirPlay-ondersteuning. Amerikaanse fabrikant consumentenelektronica Vizio kondigde eerder ondersteuning aan voor AirPlay 2 en de Home-app. Inmiddels is bekend geworden dat de specialisten van het bedrijf werken aan de SmartCast-applicatie, compatibel met AirPlay, schrijft Chronicle.info

BIOSTAR, 's werelds toonaangevende fabrikant van moederborden, videokaarten en opslagapparaten, geïntroduceerd moederbord A68MHE voor de massagebruiker. BIOSTAR A68MHE is uitgerust AMD-chipset A68H, die processors ondersteunt AMD-serie FM2+ Athlon™/A- en RAM