Looper i C: For, While, Do While looping Utsagn [Eksempler]

Hva er Loop in C?

Looping Utsagn i C utfører sekvensen av utsagn mange ganger inntil den angitte betingelsen blir usann. En løkke i C består av to deler, en løkkedel og en kontrollutsagn. Kontrollutsagnet er en kombinasjon av noen betingelser som styrer løkkedelen til å utføres inntil den angitte betingelsen blir usann. Hensikten med C-løkken er å gjenta den samme koden et antall ganger.

Typer løkker i C

Avhengig av plasseringen til en kontrollsetning i et program, seping Uttrykk i C er klassifisert i to typer:

1. Inngangsstyrt sløyfe
2. Avslutt kontrollert sløyfe

I en inngangskontrollsløyfe i C kontrolleres en betingelse før selve løkken kjøres. Dette kalles også en forhåndskontrollsløyfe.

I en utgangsstyrt løkke kontrolleres en betingelse etter at løkkens hoveddel er utført. Dette kalles også en etterkontrollløkke.

Prøvesløyfe

Kontrollbetingelsene må være godt definerte og spesifiserte, ellers vil løkken kjøres et uendelig antall ganger. Løkken som ikke stopper kjøreprosessen og behandler setningene flere ganger kalles en uendelig løkke. En uendelig løkke kalles også en «endeløs løkke». Følgende er noen kjennetegn ved en uendelig løkke:

1. Ingen oppsigelsesvilkår er spesifisert.
2. De spesifiserte betingelsene oppfylles 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 enkleste lookenping struktur. Mens løkkesyntaks i C-programmeringsspråket 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.

Mens Loop in C-programmering

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, tilordner du verdien 0 under initialiseringen.
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 skrives 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.

Do-While Loop i C-programmering

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

1. Startverdien til for-løkken utføres bare én gang.
2. Betingelsen er et boolsk uttrykk som tester og sammenligner telleren med en fast verdi etter hver iterasjon, stoppping for-løkken når `false` returneres.
3. Ø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.

For Loop in C-programmering

1. Vi har deklarert en variabel av datatypen int 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 ethvert nivå. De nestede løkkene bør være tilstrekkelig innrykket for å gjøre koden lesbar. I noen versjoner av 'C' er nestingen begrenset til opptil 15 løkker, men noen tilbyr flere.

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

Utover de tre løkketypene tilbyr C to utsagn som endrer hvordan en løkke kjører fra innsiden.

Pauseerklæring i C

Pausesetningen brukes hovedsakelig i bytte uttalelseDet er også nyttig for å stoppe umiddelbartping en løkke.

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:

1. Analyser problemet og sjekk om det krever en pre-test eller en post-test loop.
2. Hvis forhåndstesting er nødvendig, bruk en while- eller for-løkke.
3. Hvis ettertest er nødvendig, bruk en do-while-løkke.

Spørsmål og svar