Loops in C: For, While, Do While Looping Statements [Eksempler]

Kontrolbetingelserne skal være veldefinerede og specificerede, ellers vil løkken udføres et uendeligt antal gange. Sløjfen, der ikke stopper med at udføre og behandler sætningerne et antal gange, kaldes en uendelig løkke. En uendelig løkke kaldes også en "Endeløs sløjfe." Følgende er nogle karakteristika ved en uendelig sløjfe:

1. Der er ikke angivet nogen opsigelsesbetingelser.

2. De angivne betingelser opfyldes aldrig.

Den angivne betingelse bestemmer, om løkketeksten skal udføres eller ej.

Programmeringssproget 'C' giver os tre typer loop-konstruktioner:

1. While-løkken

2. Gør-mens-løkken

3. For-løkken

Mens Loop in C

A while loop er den mest ligetil looping struktur. Mens loop syntaks i C programmeringssprog er som følger:

Syntaks for While Loop i C

while (condition) {
             statements;
}

Det er en indgangskontrolleret sløjfe. I while-løkke evalueres en betingelse før behandling af en krop af løkken. Hvis en betingelse er sand, og kun derefter, udføres kroppen af ​​en løkke. Efter at en loops brødtekst er udført, går kontrol igen tilbage i begyndelsen, og betingelsen kontrolleres, om den er sand, den samme proces udføres, indtil betingelsen bliver falsk. Når tilstanden bliver falsk, går kontrollen ud af løkken.

Efter at have forladt løkken, går kontrolelementet til sætningerne, som er umiddelbart efter løkken. Brødteksten i en løkke kan indeholde mere end én sætning. Hvis den kun indeholder én erklæring, er de krøllede seler ikke obligatoriske. Det er dog en god øvelse at bruge de krøllede seler, selvom vi har et enkelt statement i kroppen.

I while-løkke, hvis betingelsen ikke er sand, vil brødteksten af ​​en løkke ikke blive udført, ikke engang én gang. Det er anderledes i do while loop, som vi snart vil se.

Følgende program illustrerer mens loop in C programmeringseksempel:

#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

Ovenstående program illustrerer brugen af ​​while-løkke. I ovenstående program har vi printet talserier fra 1 til 10 ved hjælp af en while-løkke.

1. Vi har initialiseret en variabel kaldet num med værdi 1. Vi skal udskrive fra 1 til 10, derfor initialiseres variablen med værdi 1. Hvis du vil udskrive fra 0, så tildel værdien 0 under initialisering.
2. I en while-løkke har vi givet en betingelse (num<=10), som betyder, at løkken vil udføre kroppen, indtil værdien af ​​num bliver 10. Herefter vil løkken blive afsluttet, og kontrollen vil falde uden for løkken.
3. I en løkkes krop har vi en printfunktion til at udskrive vores nummer og en stigningsoperation til at øge værdien pr. udførelse af en løkke. En begyndelsesværdi af num er 1, efter udførelsen bliver det 2, og under næste udførelse bliver det 3. Denne proces vil fortsætte indtil værdien bliver 10, og derefter vil den udskrive serien på konsollen og afslutte løkken .

\n bruges til formateringsformål, hvilket betyder, at værdien vil blive udskrevet på en ny linje.

Do-While loop i C

En do...while-løkke i C ligner while-løkken, bortset fra at betingelsen altid udføres efter brødteksten i en loop. Det kaldes også en udgangskontrolleret sløjfe.

Syntaks for do while loop i C programmeringssprog er som følger:

Syntaks for Do-While Loop i C

 do {
  statements
} while (expression);

Som vi så i en while-løkke, udføres kroppen, hvis og kun hvis betingelsen er sand. I nogle tilfælde er vi nødt til at udføre en krop af løkken mindst én gang, selvom betingelsen er falsk. Denne type operation kan opnås ved at bruge en do-while loop.

I do-while-løkken udføres en loop altid mindst én gang. Efter at kroppen er henrettet, kontrollerer den tilstanden. Hvis betingelsen er sand, vil den igen udføre kroppen af ​​en løkke, ellers overføres kontrol ud af løkken.

I lighed med while-løkken, når kontrollen går ud af løkken, er de sætninger, der er umiddelbart efter løkken er udført.

Den kritiske forskel mellem while og do-while loop er, at mens mens er skrevet i begyndelsen. I do-while loop skrives while-betingelsen i slutningen og afsluttes med et semikolon (;)

Følgende loop-program i C illustrerer arbejdet med en do-while loop:

Nedenfor er en do-while loop i C eksempel for at udskrive en tabel med nummer 2:

#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

I ovenstående eksempel har vi udskrevet multiplikationstabel med 2 ved hjælp af en do-while loop. Lad os se, hvordan programmet var i stand til at udskrive serien.

1. Først har vi initialiseret en variabel 'num' med værdien 1. Derefter har vi skrevet en do-while loop.
2. I en løkke har vi en printfunktion, der udskriver serien ved at gange værdien af ​​num med 2.
3. Efter hver stigning vil værdien af ​​num stige med 1, og den vil blive udskrevet på skærmen.
4. Indledningsvis er værdien af ​​num 1. I en body af en loop vil printfunktionen blive udført på denne måde: 2*num hvor num=1, derefter 2*1=2, derfor vil værdien to blive udskrevet. Dette vil fortsætte, indtil værdien af ​​num bliver 10. Herefter afsluttes løkken, og en sætning, som er umiddelbart efter løkken, vil blive udført. Returner i dette tilfælde 0.

Til sløjfe i C

A for loop er en mere effektiv loop struktur i 'C' programmering. Den generelle struktur af for loop syntaks i C er som følger:

Syntaks for For Loop i C

for (initial value; condition; incrementation or decrementation ) 
{
  statements;
}

• Startværdien af ​​for-løkken udføres kun én gang.
• Betingelsen er et boolsk udtryk, der tester og sammenligner tælleren med en fast værdi efter hver iteration, og stopper for-løkken, når falsk returneres.
• Inkrementeringen/nedsættelsen øger (eller mindsker) tælleren med en indstillet værdi.

Følgende program illustrerer for loop in C programmeringseksemplet:

#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

Ovenstående program udskriver nummerserien fra 1-10 ved hjælp af for loop.

1. Vi har erklæret en variabel af en int-datatype til at gemme værdier.
2. I for loop, i initialiseringsdelen, har vi tildelt værdien 1 til variabelnummeret. I tilstandsdelen har vi specificeret vores tilstand og derefter inkrementdelen.
3. I brødteksten af ​​en løkke har vi en printfunktion til at printe tallene på en ny linje i konsollen. Vi har værdien en gemt i antal, efter den første iteration vil værdien blive inkrementeret, og den bliver 2. Nu har variabeltallet værdien 2. Betingelsen vil blive kontrolleret igen, og da betingelsen er sand, vil løkke blive eksekveret, og den vil udskrive to på skærmen. Denne løkke vil blive ved med at udføre, indtil værdien af ​​variablen bliver 10. Herefter afsluttes løkken, og en serie på 1-10 vil blive udskrevet på skærmen.

I C kan for-løkken have flere udtryk adskilt af kommaer i hver del.

For eksempel:

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

Vi kan også springe det oprindelige værdiudtryk, betingelse og/eller stigning over ved at tilføje et semikolon.

For eksempel:

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

Bemærk, at løkker også kan indlejres, hvor der er en ydre løkke og en indre løkke. For hver iteration af den ydre løkke gentager den indre løkke hele sin cyklus.

Overvej følgende eksempel med flere betingelser i for loop, der bruger indlejret for loop i C-programmering til at udlæse en multiplikationstabel:

#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

Indlejring af for loops kan udføres op til ethvert niveau. De indlejrede sløjfer skal være tilstrækkeligt indrykket for at gøre koden læsbar. I nogle versioner af 'C' er indlejringen begrænset til 15 sløjfer, men nogle giver flere.

De indlejrede loops bruges mest i array-applikationer, som vi vil se i yderligere tutorials.

Pauseerklæring i C

Pausesætningen bruges hovedsageligt i skifte erklæring. Det er også nyttigt til øjeblikkeligt at stoppe en løkke.

Vi overvejer følgende program, som introducerer en pause for at afslutte en while-løkke:

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

Output:

5
4

Fortsæt erklæring i C

Når du vil springe til næste iteration, men forblive i løkken, skal du bruge continu-sætningen.

For eksempel:

#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

Så værdien 5 springes over.

Hvilken sløjfe skal du vælge?

Valg af en loop er altid en svær opgave for en programmør, for at vælge en loop skal du udføre følgende trin:

• Analyser problemet og tjek, om det kræver en pre-test eller en post-test loop.
• Hvis prætest er påkrævet, brug et stykke tid eller til en løkke.
• Hvis eftertest er påkrævet, skal du bruge en do-while loop.

Resumé

• Definer loop i C: En Loop er et af nøglebegreberne på enhver Programmeringssprog. Sløjfer i C-sprog implementeres ved hjælp af betingede udsagn.
• En blok af sløjfekontroludsagn i C udføres et antal gange, indtil betingelsen bliver falsk.
• Sløjfer i C-programmering er af 2 typer: indgangskontrollerede og udgangskontrollerede.
• Liste forskellige loop kontrol instruktioner i C: C programmering giver os 1) mens 2) do-while og 3) for loop kontrol instruktioner.
• For og mens loop C-programmering er indgangskontrollerede loops i C-sprog.
• Do-while er en udgangskontrolløkke i C.