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

Kontrollbetingelsene må være godt definert og spesifisert ellers vil sløyfen utføres et uendelig antall ganger. Sløyfen som ikke slutter å utføre og behandler setningene antall ganger kalles som en uendelig sløyfe. En uendelig løkke kalles også en "Endeløs loop." Følgende er noen kjennetegn ved en uendelig løkke:

1. Ingen oppsigelsesvilkår er spesifisert.

2. De angitte vilkårene oppfyller aldri.

Den spesifiserte betingelsen bestemmer om løkketeksten skal kjøres eller ikke.

'C' programmeringsspråk gir oss tre typer sløyfekonstruksjoner:

1. While-løkken

2. Do-while-løkken

3. For-løkken

Mens Loop in C

En while-løkke er den mest enkle løkkestrukturen. Mens loop-syntaks i C programmeringsspråk er som følger:

Syntaks for While Loop i C

while (condition) {
             statements;
}

Det er en inngangskontrollert sløyfe. I while-løkken blir en tilstand evaluert før behandlingen av en kropp av løkken. Hvis en betingelse er sann da, og bare da, blir kroppen til en løkke utført. Etter at hoveddelen av en sløyfe er utført, går kontrollen tilbake i begynnelsen, og betingelsen sjekkes om den er sann, den samme prosessen utføres til betingelsen blir usann. Når tilstanden blir falsk, går kontrollen ut av løkken.

Etter å ha gått ut av loopen, går kontrollen til setningene som er umiddelbart etter loopen. Brødteksten i en loop kan inneholde mer enn én setning. Hvis den bare inneholder én setning, er ikke de krøllete tannreguleringene obligatoriske. Det er en god praksis å bruke de krøllete tannreguleringene, selv om vi har en enkelt uttalelse i kroppen.

I while-løkke, hvis betingelsen ikke er sann, vil ikke brødteksten til en løkke bli utført, ikke en gang. Det er annerledes i do while-løkken som vi vil se snart.

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

Utgang:

1
2
3
4
5
6
7
8
9
10

Programmet ovenfor illustrerer bruken av while-løkke. I programmet ovenfor har vi skrevet ut serier med tall fra 1 til 10 ved hjelp av en while-løkke.

1. Vi har initialisert en variabel kalt num med verdi 1. Vi skal skrive ut fra 1 til 10, derfor initialiseres variabelen med verdi 1. Hvis du vil skrive ut fra 0, tilordne verdien 0 under initialisering.
2. I løpet av en while-løkke har vi gitt en betingelse (num<=10), som betyr at loopen vil utføre kroppen til verdien av num blir 10. Etter det vil loopen bli avsluttet, og kontrollen vil falle utenfor loopen.
3. I brødteksten til en løkke har vi en utskriftsfunksjon for å skrive ut nummeret vårt og en inkrementoperasjon for å øke verdien per utførelse av en løkke. En startverdi av num er 1, etter utførelsen vil den bli 2, og under neste kjøring vil den bli 3. Denne prosessen vil fortsette til verdien blir 10 og deretter vil den skrive ut serien på konsollen og avslutte sløyfen .

\n brukes til formateringsformål som betyr at verdien vil bli skrevet ut på en ny linje.

Do-While-løkke i C

En do...while-løkke i C ligner på while-løkken, bortsett fra at betingelsen alltid utføres etter brødteksten til en løkke. Det kalles også en utgangskontrollert sløyfe.

Syntaksen for do while loop i C programmeringsspråk er som følger:

Syntaks for Do-While Loop i C

 do {
  statements
} while (expression);

Som vi så i en while-løkke, utføres kroppen hvis og bare hvis betingelsen er sann. I noen tilfeller må vi utføre en body av loopen minst én gang selv om betingelsen er falsk. Denne typen operasjon kan oppnås ved å bruke en do-while-løkke.

I do-while-løkken kjøres kroppen til en loop alltid minst én gang. Etter at kroppen er henrettet, sjekker den tilstanden. Hvis betingelsen er sann, vil den igjen utføre kroppen til en sløyfe, ellers overføres kontrollen ut av sløyfen.

I likhet med while-løkken, når kontrollen går ut av løkken, er setningene som er umiddelbart etter at løkken er utført.

Den kritiske forskjellen mellom while- og do-while-løkken er at mens-løkken er skrevet i begynnelsen. I do-while loop skrives while-betingelsen på slutten og avsluttes med semikolon (;)

Følgende loop-program i C illustrerer hvordan en do-while-løkke fungerer:

Nedenfor er en do-while-løkke i C-eksempel for å skrive ut en tabell 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;
}

Utgang:

2
4
6
8
10
12
14
16
18
20

I eksemplet ovenfor har vi skrevet ut multiplikasjonstabell med 2 ved å bruke en do-while-løkke. La oss se hvordan programmet klarte å skrive ut serien.

1. Først har vi initialisert en variabel 'num' med verdi 1. Deretter har vi skrevet en do-while loop.
2. I en løkke har vi en utskriftsfunksjon som vil skrive ut serien ved å multiplisere verdien av num med 2.
3. Etter hver økning vil verdien av num øke med 1, og den vil bli skrevet ut på skjermen.
4. Innledningsvis er verdien av num 1. I en brødtekst av en løkke vil utskriftsfunksjonen bli utført på denne måten: 2*num hvor num=1, deretter 2*1=2, derfor vil verdien to bli skrevet ut. Dette vil fortsette til verdien av num blir 10. Etter den vil løkken avsluttes og en setning som er umiddelbart etter løkken vil bli utført. Returner i dette tilfellet 0.

For loop i C

A for loop er en mer effektiv loopstruktur i 'C'-programmering. Den generelle strukturen til for loop-syntaks i C er som følger:

Syntaks for For Loop i C

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

• Startverdien til for-løkken utføres bare én gang.
• Betingelsen er et boolsk uttrykk som tester og sammenligner telleren med en fast verdi etter hver iterasjon, og stopper for-løkken når false returneres.
• Økningen/dekrementeringen øker (eller reduserer) telleren med en innstilt verdi.

Følgende program illustrerer for loop in C programmeringseksempel:

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

Utgang:

1
2
3
4
5
6
7
8
9
10

Programmet ovenfor skriver ut tallserien fra 1-10 med for loop.

1. Vi har erklært en variabel av en int-datatype for å lagre verdier.
2. I for loop, i initialiseringsdelen, har vi tildelt verdi 1 til variabelnummeret. I tilstandsdelen har vi spesifisert vår tilstand og deretter inkrementdelen.
3. I hoveddelen av en løkke har vi en utskriftsfunksjon for å skrive ut tallene på en ny linje i konsollen. Vi har verdien en lagret i antall, etter den første iterasjonen vil verdien økes, og den blir 2. Nå har variabeltallet verdien 2. Betingelsen vil bli sjekket på nytt og siden betingelsen er sann, vil løkke bli utført, og den vil skrive ut to på skjermen. Denne sløyfen vil fortsette å kjøre til verdien av variabelen blir 10. Etter det vil løkken avsluttes, og en serie på 1-10 vil bli skrevet ut på skjermen.

I C kan for-løkken ha flere uttrykk atskilt med komma i hver del.

For eksempel:

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

Vi kan også hoppe over startverdiuttrykket, betingelsen og/eller inkrementet ved å legge til et semikolon.

For eksempel:

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

Legg merke til at løkker også kan nestes der det er en ytre løkke og en indre løkke. For hver iterasjon av den ytre sløyfen, gjentar den indre sløyfen hele sin syklus.

Tenk på følgende eksempel med flere betingelser i for loop, som bruker nestet for loop i C-programmering for å sende ut en multiplikasjonstabell:

#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 */
}}

Utgang:

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

Nesting av for-løkker kan gjøres opp til alle nivåer. De nestede løkkene bør være tilstrekkelig innrykket for å gjøre koden lesbar. I noen versjoner av 'C' er hekkingen begrenset til 15 løkker, men noen gir flere.

De nestede løkkene brukes mest i array-applikasjoner som vi vil se i videre opplæringsprogrammer.

Pauseerklæring i C

Pausesetningen brukes hovedsakelig i bytte uttalelse. Den er også nyttig for umiddelbart å stoppe en sløyfe.

Vi vurderer følgende program som introduserer en pause for å avslutte en while-løkke:

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

Utgang:

5
4

Fortsett uttalelse i C

Når du vil hoppe til neste iterasjon, men forbli i loopen, bør du bruke continu-setningen.

For eksempel:

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

Utgang:

6
4
3
2
1

Så verdien 5 hoppes over.

Hvilken sløyfe å velge?

Valg av en sløyfe er alltid en tøff oppgave for en programmerer, for å velge en sløyfe gjør følgende trinn:

• Analyser problemet og sjekk om det krever en pre-test eller en post-test loop.
• Hvis forhåndstest er nødvendig, bruk en stund eller for en sløyfe.
• Hvis ettertest er nødvendig, bruk en do-while-løkke.

Sammendrag

• Definer sløyfe i C: En sløyfe er et av nøkkelbegrepene på enhver Programmeringsspråk. Sløyfer i C-språk implementeres ved hjelp av betingede utsagn.
• En blokk med sløyfekontrollsetninger i C utføres et antall ganger til betingelsen blir falsk.
• Sløyfer i C-programmering er av 2 typer: inngangskontrollert og utgangskontrollert.
• Liste ulike sløyfekontrollinstruksjoner i C: C-programmering gir oss 1) mens 2) do-while og 3) for sløyfekontrollinstruksjoner.
• For og mens loop C-programmering er inngangskontrollerte looper i C-språk.
• Do-while er en utgangskontrollsløyfe i C.