Loops in C:For, While, Do While-statements [voorbeelden]

De controlevoorwaarden moeten goed gedefinieerd en gespecificeerd zijn, anders zal de lus een oneindig aantal keren worden uitgevoerd. De lus die niet stopt met uitvoeren en de instructies een aantal keren verwerkt, wordt een oneindige lus genoemd . Een oneindige lus wordt ook wel een "Eindeloze lus . genoemd .” Hieronder volgen enkele kenmerken van een oneindige lus:

1. Er is geen beëindigingsvoorwaarde gespecificeerd.

2. De opgegeven voorwaarden voldoen nooit.

De gespecificeerde voorwaarde bepaalt of de loop body moet worden uitgevoerd of niet.

De programmeertaal 'C' biedt ons drie soorten lusconstructies:

1. De while-lus

2. De do-while-lus

3. De for-lus

Terwijl lus in C

Een while-lus is de meest eenvoudige loopstructuur. While-lussyntaxis in programmeertaal C is als volgt:

Syntaxis van While-lus in C:

while (condition) {
             statements;
}

Het is een ingang-gecontroleerde lus. In while-lus wordt een voorwaarde geëvalueerd voordat een hoofdtekst van de lus wordt verwerkt. Als een voorwaarde waar is, dan en alleen dan wordt de body van een lus uitgevoerd. Nadat de hoofdtekst 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, gaat de besturing uit de lus.

Na het verlaten van de lus gaat de besturing naar de instructies die zich direct na de lus bevinden. De hoofdtekst van een lus kan meer dan één instructie bevatten. Als het maar één uitspraak bevat, zijn de accolades niet verplicht. Het is echter een goede gewoonte om de accolades te gebruiken, zelfs als we een enkele verklaring in de body hebben.

Als in een while-lus de voorwaarde niet waar is, wordt de hoofdtekst 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 een 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;
}

Uitvoer:

1
2
3
4
5
6
7
8
9
10

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

While Loop in C-programmering

1. We hebben een variabele met de naam num geïnitialiseerd met waarde 1. We gaan van 1 tot 10 afdrukken, daarom wordt de variabele geïnitialiseerd met waarde 1. Als u vanaf 0 wilt afdrukken, wijst u de waarde 0 toe tijdens de initialisatie.
li>
2. In een while-lus hebben we een voorwaarde (num<=10) gegeven, wat betekent dat de lus de body uitvoert totdat de waarde van num 10 wordt. Daarna wordt de lus beëindigd en valt de controle buiten de de lus.
3. In de body van een lus hebben we een printfunctie om ons nummer af te drukken en een increment-operatie 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 zal het de serie op de console afdrukken en de lus beëindigen .

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

Do-While-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.

Syntaxis van do while-lus in programmeertaal C is als volgt:

Syntaxis van Do-While Loop 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 het lichaam is uitgevoerd, controleert het de voorwaarde. Als de voorwaarde waar is, wordt de hoofdtekst van een lus opnieuw uitgevoerd, anders wordt de besturing uit de lus overgedragen.

Net als bij de while-lus, zodra de besturing uit de lus gaat, worden de instructies die onmiddellijk na de lus worden uitgevoerd, uitgevoerd.

Het cruciale verschil tussen de while- en de do-while-lus is dat in de 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 loopprogramma in C illustreert de werking van een do-while loop:

Hieronder is een do-while-lus in C-voorbeeld om een ​​tabel van 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;
}

Uitvoer:

2
4
6
8
10
12
14
16
18
20

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

Do-While Loop in C-programmering

1. Eerst hebben we een variabele 'num' geïnitialiseerd met waarde 1. Daarna hebben we een do-while-lus geschreven.
2. In een lus hebben we een afdrukfunctie die de reeks afdrukt door de waarde van num met 2 te vermenigvuldigen.
3. Na elke stap wordt de waarde van num met 1 verhoogd en wordt deze op het scherm afgedrukt.
4. Aanvankelijk is de waarde van num 1. In een body 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 instructie uitgevoerd die direct na de lus staat. Retourneer in dit geval 0.

For-lus in C

Een for-lus is een efficiëntere lusstructuur in 'C'-programmering. De algemene structuur van de for-lus-syntaxis 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 maar één keer uitgevoerd.
• De voorwaarde is een Booleaanse expressie die de teller na elke iteratie test en vergelijkt met een vaste waarde, waarbij de for-lus wordt gestopt wanneer false wordt geretourneerd.
• De verhoging/verlaging verhoogt (of verlaagt) de teller met een ingestelde waarde.

Het volgende programma illustreert de for-lus in 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;
}

Uitvoer:

1
2
3
4
5
6
7
8
9
10

Het bovenstaande programma drukt de getallenreeksen van 1-10 af met for-lus.

For Loop in C-programmering

1. We hebben een variabele van het gegevenstype int gedeclareerd om waarden op te slaan.
2. In for loop, in het initialisatiegedeelte, hebben we waarde 1 toegekend aan het variabelenummer. In het voorwaardegedeelte hebben we onze voorwaarde gespecificeerd en vervolgens het incrementele gedeelte.
3. In de body van een lus hebben we een printfunctie om de nummers op een nieuwe regel in de console af te drukken. We hebben de waarde één opgeslagen in nummer, na de eerste iteratie wordt de waarde verhoogd en wordt het 2. Nu heeft het variabele nummer de waarde 2. De voorwaarde wordt opnieuw gecontroleerd en aangezien de voorwaarde waar is, wordt de lus uitgevoerd, en het zal er twee op het scherm afdrukken. Deze lus wordt uitgevoerd totdat de waarde van de variabele 10 wordt. Daarna wordt de lus beëindigd en wordt 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 waar er een buitenste lus en een binnenste lus is. Voor elke iteratie van de buitenste lus herhaalt de binnenste lus zijn hele cyclus.

Beschouw het volgende voorbeeld met meerdere voorwaarden in for-lus, dat geneste for-lus in C-programmering 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 */
}}

Uitvoer:

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-lussen kan tot op elk niveau. De geneste lussen moeten voldoende worden ingesprongen om de code leesbaar te maken. In sommige versies van 'C' is het nesten beperkt tot 15 lussen, maar sommige bieden meer.

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

Break Statement 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 pauze introduceert om een ​​while-lus te verlaten:

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

Uitvoer:

5
4

Vervolg verklaring in C

Als u naar de volgende iteratie wilt gaan maar op de hoogte 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);
}}

Uitvoer:

6
4
3
2
1

De waarde 5 wordt dus overgeslagen.

Welke lus selecteren?

Het selecteren van een lus is altijd een moeilijke taak voor een programmeur, om een ​​lus te selecteren volgt u de volgende stappen:

• Analyseer het probleem en controleer of het een pre-test of een post-test lus vereist.
• Als een pre-test nodig is, gebruik dan een while of voor een lus.
• Als een natest vereist is, gebruik dan een do-while-lus.

Samenvatting

• Definieer lus in C:Een lus is een van de belangrijkste concepten in elke programmeertaal. Loops in C-taal worden geïmplementeerd met behulp van voorwaardelijke instructies.
• Een blok lusbesturingsinstructies in C wordt een aantal keren uitgevoerd totdat de voorwaarde onwaar wordt.
• Lussen in C-programmering zijn van 2 soorten:ingangsgestuurd en uitgangsgestuurd.
• Maak een lijst van verschillende lusbesturingsinstructies in C:C-programmering biedt ons 1) terwijl 2) do-while en 3) voor lusbesturingsinstructies.
• Voor- en while-lus C-programmering zijn ingangsgestuurde lussen in C-taal.
• Do-while is een uitgangscontrolelus in C.