Lussen in C: For, While, Do Whileping Uitspraken [Voorbeelden]

Wat is lus in C?

Toiletping Instructies in C voeren een reeks instructies vele malen uit totdat de opgegeven voorwaarde onwaar wordt. Een lus in C bestaat uit twee delen: de lusbody en een besturingsinstructie. De besturingsinstructie is een combinatie van voorwaarden die de lusbody aansturen om te worden uitgevoerd totdat de opgegeven voorwaarde onwaar wordt. Het doel van een C-lus is om dezelfde code een aantal keren te herhalen.

Soorten lussen in C

Afhankelijk van de positie van een besturingsinstructie in een programma, kan de uitvoer ervan variëren.ping Instructies in C worden in twee typen ingedeeld:

1. Ingang gecontroleerde lus
2. Verlaat de gecontroleerde lus

In een entry control loop in C wordt een voorwaarde gecontroleerd voordat de body van de lus wordt uitgevoerd. Dit wordt ook wel een pre-checking loop genoemd.

In een exit-gecontroleerde lus wordt een voorwaarde gecontroleerd nadat de lusbody is uitgevoerd. Dit wordt ook wel een post-checking lus genoemd.

Voorbeeldlus

De besturingsvoorwaarden moeten goed gedefinieerd en gespecificeerd zijn, anders zal de lus oneindig vaak worden uitgevoerd. Een lus die niet stopt met uitvoeren en de instructies een oneindig 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 gestelde voorwaarden worden nooit vervuld.

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

While-lus in C

Een while-lus is de meest eenvoudige lus.ping structuur. De syntaxis van een while-lus 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 Loop in C-programmering

1. We hebben een initialisatie uitgevoerd variabele De variabele heet num en heeft de waarde 1. We gaan de getallen 1 tot en met 10 afdrukken, daarom is de variabele geïnitialiseerd met de waarde 1. Als je vanaf 0 wilt afdrukken, wijs dan de waarde 0 toe tijdens de initialisatie.
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.

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;
}

1. De initiële waarde van de for-lus wordt slechts één keer uitgevoerd.
2. De voorwaarde is een Booleaanse expressie die de teller na elke iteratie test en vergelijkt met een vaste waarde; stopping De for-lus retourneert onwaar wanneer deze wordt geretourneerd.
3. 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-programmering

1. We hebben een variabele van het gegevenstype int gedeclareerd 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-lussen kan tot elk gewenst niveau. De geneste lussen moeten voldoende ingesprongen zijn om de code leesbaar te houden. In sommige versies van 'C' is het nesten beperkt tot 15 lussen, maar in andere versies is dit niet mogelijk.

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

Naast de drie lussoorten biedt C twee instructies waarmee de werking van een lus van binnenuit kan worden gewijzigd.

Break-verklaring in C

De break-instructie wordt voornamelijk gebruikt in de switch-instructieHet is ook handig om direct te stoppen.ping een lus.

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:

1. Analyseer het probleem en controleer of er een pre-test of een post-testlus nodig is.
2. Als een voorcontrole vereist is, gebruik dan een while- of for-lus.
3. Als een post-test vereist is, gebruik dan een do-while-lus.

Veelgestelde vragen