Loops in C: For, While, Do While looping-instructies [Voorbeelden]

Wat is lus in C?

Looping-instructies in C voer de reeks instructies vele malen uit totdat de opgegeven voorwaarde onwaar wordt. Een lus in C bestaat uit twee delen: een hoofdgedeelte van een lus en een controle-instructie. De control-instructie is een combinatie van enkele voorwaarden die ervoor zorgen dat de hoofdtekst van de lus wordt uitgevoerd totdat de opgegeven voorwaarde onwaar wordt. Het doel van de C-lus is om dezelfde code een aantal keren te herhalen.

Soorten lussen in C

Afhankelijk van de positie van een controle-instructie in een programma, wordt de looping-instructie in C in twee typen ingedeeld:

1. Ingangsgestuurde lus

2. Verlaat de gecontroleerde lus

In een toegangscontrolelus in C, een voorwaarde wordt gecontroleerd voordat de hoofdtekst van een lus wordt uitgevoerd. Het wordt ook wel een pre-controlelus genoemd.

In een verlaat de gecontroleerde lus, wordt een voorwaarde gecontroleerd na het uitvoeren van de hoofdtekst van een lus. Het wordt ook wel een post-checking-lus genoemd.

Soorten lussen in C
Voorbeeldlus

De controlevoorwaarden moeten goed gedefinieerd en gespecificeerd zijn, anders wordt de lus oneindig vaak uitgevoerd. De lus die niet stopt met uitvoeren en de statements een aantal keer verwerkt, wordt een oneindige lus. Een oneindige lus wordt ook wel een “Eindeloze cirkelHieronder volgen enkele kenmerken van een oneindige lus:

1. Er is geen opzeggingsvoorwaarde gespecificeerd.

2. Aan de opgegeven voorwaarden wordt nimmer voldaan.

De opgegeven voorwaarde bepaalt of de lusbody al dan niet moet worden uitgevoerd.

De programmeertaal 'C' biedt ons drie soorten lusconstructies:

1. De while-lus

2. De do-while-lus

3. De for-lus

Sorry. Nee. Lus type Beschrijving
1. Herhalingslus In while-lus wordt een voorwaarde geëvalueerd voordat de hoofdtekst van de lus wordt verwerkt. Als een voorwaarde waar is, dan en alleen dan wordt de body van een lus uitgevoerd.
2. Doe-terwijl-lus In een do…while-lus wordt de voorwaarde altijd uitgevoerd na de hoofdtekst van een lus. Het wordt ook wel een uitgangsgestuurde lus genoemd.
3. For loop In een for-lus wordt de beginwaarde slechts één keer uitgevoerd. Vervolgens test en vergelijkt de voorwaarde de teller na elke iteratie met een vaste waarde. De for-lus wordt gestopt als false wordt geretourneerd.

While-lus in C

Een while-lus is de meest rechttoe rechtaan looping-structuur. De while-lus-syntaxis in de programmeertaal C is als volgt:

Syntaxis van While-lus in C

while (condition) {
             statements;
}

Het is een ingangsgestuurde lus. In while-lus wordt een voorwaarde geëvalueerd voordat de hoofdtekst van de lus wordt verwerkt. Als een voorwaarde waar is, dan en alleen dan wordt de body van een lus uitgevoerd. Nadat de body van een lus is uitgevoerd, gaat de besturing weer terug naar het begin en wordt gecontroleerd of de voorwaarde waar is. Hetzelfde proces wordt uitgevoerd totdat de voorwaarde onwaar wordt. Zodra de voorwaarde onwaar wordt, verdwijnt de controle uit de lus.

Na het verlaten van de lus gaat de besturing naar de instructies die onmiddellijk na de lus staan. De body van een lus kan meer dan één statement bevatten. Als er slechts één stelling in staat, zijn de accolades niet verplicht. Het is echter een goede gewoonte om de accolades te gebruiken, ook al hebben we maar één statement in de body.

Als in de while-lus de voorwaarde niet waar is, wordt de body van een lus niet uitgevoerd, zelfs niet één keer. Het is anders in de do while-lus, die we binnenkort zullen zien.

Het volgende programma illustreert de while-lus in een C-programmeervoorbeeld:

#include<stdio.h>
#include<conio.h>
int main()
{
	int num=1;	//initializing the variable
	while(num<=10)	//while loop with condition
	{
		printf("%d\n",num);
		num++;		//incrementing operation
	}
	return 0;
}

Output:

1
2
3
4
5
6
7
8
9
10

Het bovenstaande programma illustreert het gebruik van de while-lus. In het bovenstaande programma hebben we een reeks getallen van 1 tot 10 afgedrukt met behulp van een while-lus.

While-lus in C
While Loop in C-programmering
  1. We hebben een variabele geïnitialiseerd met de naam num met waarde 1. We gaan afdrukken van 1 tot 10 en daarom wordt de variabele geïnitialiseerd met waarde 1. Als u vanaf 0 wilt afdrukken, wijst u tijdens de initialisatie de waarde 0 toe.
  2. In een while-lus hebben we een voorwaarde opgegeven (num<=10), wat betekent dat de lus de body zal uitvoeren totdat de waarde van num 10 wordt. Daarna wordt de lus beëindigd en valt de besturing buiten de lus.
  3. In de body van een lus hebben we een printfunctie om ons nummer te printen en een incrementbewerking om de waarde per uitvoering van een lus te verhogen. Een beginwaarde van num is 1, na de uitvoering wordt het 2 en tijdens de volgende uitvoering wordt het 3. Dit proces gaat door totdat de waarde 10 wordt en dan wordt de serie op de console geprint en wordt de lus beëindigd.

\n wordt gebruikt voor opmaakdoeleinden, wat betekent dat de waarde op een nieuwe regel wordt afgedrukt.

Doe-terwijl-lus in C

Een do…while-lus in C is vergelijkbaar met de while-lus, behalve dat de voorwaarde altijd wordt uitgevoerd na de hoofdtekst van een lus. Het wordt ook wel een uitgangsgestuurde lus genoemd.

De syntaxis van de do while-lus in de programmeertaal C is als volgt:

Syntaxis van Do-While-lus in C

 do {
  statements
} while (expression);

Zoals we zagen in een while-lus, wordt de body uitgevoerd als en alleen als de voorwaarde waar is. In sommige gevallen moeten we een body van de lus minstens één keer uitvoeren, zelfs als de voorwaarde onwaar is. Dit type bewerking kan worden bereikt door een do-while-lus te gebruiken.

In de do-while-lus wordt de body van een lus altijd minstens één keer uitgevoerd. Nadat de body is uitgevoerd, controleert het de voorwaarde. Als de voorwaarde waar is, wordt de body van een lus opnieuw uitgevoerd, anders wordt de controle uit de lus overgedragen.

Vergelijkbaar met de while-lus: zodra het besturingselement de lus verlaat, worden de instructies onmiddellijk na de lus uitgevoerd.

Het cruciale verschil tussen de while- en do-while-lus is dat in while-lus de while aan het begin wordt geschreven. In de do-while-lus wordt de while-voorwaarde aan het einde geschreven en eindigt met een puntkomma (;)

Het volgende lusprogramma in C illustreert de werking van een do-while-lus:

Hieronder ziet u een do-while-lus in het C-voorbeeld om een ​​tabel met nummer 2 af te drukken:

#include<stdio.h>
#include<conio.h>
int main()
{
	int num=1;	//initializing the variable
	do	//do-while loop 
	{
		printf("%d\n",2*num);
		num++;		//incrementing operation
	}while(num<=10);
	return 0;
}

Output:

2
4
6
8
10
12
14
16
18
20

In het bovenstaande voorbeeld hebben we de tafel van vermenigvuldiging van 2 afgedrukt met behulp van een do-while-lus. Laten we eens kijken hoe het programma de serie kon afdrukken.

Doe-terwijl-lus in C
Do-While-lus in C-programmering
  1. Eerst hebben we een variabele 'num' met waarde 1 geïnitialiseerd. Vervolgens hebben we een do-while-lus geschreven.
  2. In een lus hebben we een printfunctie die de reeks afdrukt door de waarde van num met 2 te vermenigvuldigen.
  3. Na elke verhoging wordt de waarde van num met 1 verhoogd en wordt deze op het scherm afgedrukt.
  4. Aanvankelijk is de waarde van num 1. In de hoofdtekst van een lus wordt de printfunctie op deze manier uitgevoerd: 2*num waarbij num=1, dan 2*1=2, vandaar dat de waarde twee wordt afgedrukt. Dit gaat door totdat de waarde van num 10 wordt. Daarna wordt de lus beëindigd en wordt een statement uitgevoerd dat onmiddellijk na de lus volgt. In dit geval retourneert u 0.

Voor lus in C

Een for-lus is een efficiëntere lusstructuur bij 'C'-programmering. De algemene structuur van de for-lussyntaxis in C is als volgt:

Syntaxis van For Loop in C

for (initial value; condition; incrementation or decrementation ) 
{
  statements;
}
  • De initiële waarde van de for-lus wordt slechts één keer uitgevoerd.
  • De voorwaarde is een Booleaanse expressie die de teller na elke iteratie test en vergelijkt met een vaste waarde, en de for-lus stopt wanneer false wordt geretourneerd.
  • Door het verhogen/verlagen wordt de teller met een ingestelde waarde verhoogd (of verlaagd).

Het volgende programma illustreert de for-lus in een C-programmeervoorbeeld:

#include<stdio.h>
int main()
{
	int number;
	for(number=1;number<=10;number++)	//for loop to print 1-10 numbers
	{
		printf("%d\n",number);		//to print the number
	}
	return 0;
}

Output:

1
2
3
4
5
6
7
8
9
10

Het bovenstaande programma drukt de nummerreeksen van 1-10 af met behulp van een for-lus.

Voor lus in C
Voor lus in C-programmering
  1. Wij hebben verklaard een variabele van een int-gegevenstype om waarden op te slaan.
  2. In de for-lus hebben we in het initialisatiegedeelte waarde 1 toegewezen aan het variabelenummer. In het voorwaardegedeelte hebben we onze voorwaarde gespecificeerd en vervolgens het verhogingsgedeelte.
  3. In de body van een lus hebben we een printfunctie om de getallen op een nieuwe regel in de console af te drukken. We hebben de waarde één opgeslagen in number, na de eerste iteratie wordt de waarde verhoogd en wordt het 2. Nu heeft de variabele number de waarde 2. De conditie wordt opnieuw gecontroleerd en omdat de conditie waar is, wordt de lus uitgevoerd en wordt er twee op het scherm afgedrukt. Deze lus blijft worden uitgevoerd totdat de waarde van de variabele 10 wordt. Daarna wordt de lus beëindigd en wordt er een reeks van 1-10 op het scherm afgedrukt.

In C kan de for-lus meerdere expressies bevatten, gescheiden door komma's in elk deel.

Bijvoorbeeld:

for (x = 0, y = num; x < y; i++, y--) { 
  statements; 
}

We kunnen ook de initiële waarde-expressie, voorwaarde en/of verhoging overslaan door een puntkomma toe te voegen.

Bijvoorbeeld:

int i=0;
int max = 10;
for (; i < max; i++) {
  printf("%d\n", i);
}

Merk op dat lussen ook kunnen worden genest als er een buitenste lus en een binnenste lus zijn. Voor elke iteratie van de buitenste lus herhaalt de binnenste lus zijn hele cyclus.

Overweeg het volgende voorbeeld met meerdere voorwaarden in een for-lus, waarbij een geneste for-lus in C-programmering wordt gebruikt om een ​​vermenigvuldigingstabel uit te voeren:

#include <stdio.h>
int main() {
int i, j;
int table = 2;
int max = 5;
for (i = 1; i <= table; i++) { // outer loop
  for (j = 0; j <= max; j++) { // inner loop
    printf("%d x %d = %d\n", i, j, i*j);
  }
  printf("\n"); /* blank line between tables */
}}

Output:

1 x 0 = 0
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5

2 x 0 = 0
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10

Het nesten van for-loops kan tot op elk niveau worden gedaan. De geneste loops moeten voldoende worden ingesprongen om code leesbaar te maken. In sommige versies van 'C' is het nesten beperkt tot 15 loops, maar sommige bieden meer.

De geneste lussen worden meestal gebruikt in array-toepassingen, die we in verdere tutorials zullen zien.

Break-verklaring in C

De break-instructie wordt voornamelijk gebruikt in de switch-instructie. Het is ook handig om een ​​lus onmiddellijk te stoppen.

We beschouwen het volgende programma dat een break introduceert om een ​​while-lus te beëindigen:

#include <stdio.h>
int main() {
int num = 5;
while (num > 0) {
  if (num == 3)
    break;
  printf("%d\n", num);
  num--;
}}

Output:

5
4

Ga verder met de verklaring in C

Als u naar de volgende iteratie wilt gaan maar in de lus wilt blijven, moet u de instructie continue gebruiken.

Bijvoorbeeld:

#include <stdio.h>
int main() {
int nb = 7;
while (nb > 0) {
  nb--;
  if (nb == 5)
    continue;
 printf("%d\n", nb);
}}

Output:

6
4
3
2
1

De waarde 5 wordt dus overgeslagen.

Welke lus selecteren?

Het selecteren van een lus is altijd een lastige taak voor een programmeur. Om een ​​lus te selecteren, volgt u de volgende stappen:

  • Analyseer het probleem en controleer of er een pre-test of een post-testlus nodig is.
  • Als een voortest vereist is, gebruik dan een while of for a loop.
  • Als een post-test vereist is, gebruik dan een do-while-lus.

Samenvatting

  • Definieer een lus in C: Een lus is een van de belangrijkste concepten in elk Programmeertaal. Lussen in C-taal worden geïmplementeerd met behulp van voorwaardelijke instructies.
  • Een blok met lusbesturingsinstructies in C wordt een aantal keren uitgevoerd totdat de voorwaarde onwaar wordt.
  • Er zijn 2 soorten lussen in C-programmering: ingangsgestuurd en uitgangsgestuurd.
  • Noem verschillende lusbesturingsinstructies in C: C-programmering biedt ons 1) terwijl 2) do-while en 3) lusbesturingsinstructies.
  • For en while-lus C-programmering zijn invoergestuurde lussen in C-taal.
  • Do-while is een exit-controlelus in C.