Innholdsfortegnelse:
- Hva er mens Loop i C++
- Syntaks for while Loop
- Slik bruker du mens du looper i C++
- C++ Nestet mens Loop
- C++ Uendelig mens Loop
- Skrive ut partall og oddetall med while-løkker i C++
- Konklusjon
Hva er mens Loop i C++
En while-løkke er en kontrollstruktur som vil fortsette å kjøre så lenge tilstanden evalueres til sann, og den vil stoppe når tilstanden blir usann. Det er nyttig i tilfeller der du ønsker å gjenta en bestemt oppgave til en bestemt betingelse er oppfylt.
For eksempel , kan du bruke en while-løkke til å skrive ut tall fra 1 til 10 eller beregne et gitt talls faktorial.
Syntaks for while Loop
Den grunnleggende syntaksen for en while-løkke i C++ er som følger:
samtidig som ( betingelse ) {
// kode som skal kjøres
}
Koden innenfor de krøllete klammeparentesene vil bli utført gjentatte ganger så lenge betingelsen er sann. Tilstanden vil bli sjekket hver gang sløyfen kjører.
Slik bruker du mens du looper i C++
Et av de vanligste eksemplene på mens-løkker teller fra et startpunkt til et endepunkt. For eksempel, følgende kode vil telle fra 1 til 10:
#includebruker navneområde std ;
int hoved- ( ) {
int Jeg = 1 ; // initialiser tellervariabelen til 1
// løkke mens tellervariabelen er mindre enn eller lik 10
samtidig som ( Jeg <= 10 ) {
cout << Jeg << endl ; // gi ut gjeldende verdi av tellervariabelen
Jeg ++; // øke tellervariabelen
}
komme tilbake 0 ;
}
Denne koden viser hvordan du bruker en while-løkke i C++. Programmet initialiserer en tellervariabel Jeg til 1 og kjører deretter en while-løkke som vil fortsette å kjøre til Jeg blir større enn 10.
Inne i while-løkken skrives gjeldende verdi av tellervariabelen til konsollen ved hjelp av cout setning, etterfulgt av et linjeskift ved hjelp av endl . Tellervariabelen økes deretter med 1 ved å bruke i++ uttalelse.
Sløyfen fortsetter å kjøre til tellervariabelen Jeg når en verdi på 11, på hvilket tidspunkt mens-løkken avsluttes og programmet avsluttes med en returverdi på 0.
C++ Nestet mens Loop
Mens-løkkene kan også være nestet , som betyr at du kan ha en while-løkke inne i en annen while-løkke. Dette er nyttig i tilfeller der du trenger å utføre en oppgave gjentatte ganger til en bestemt betingelse er oppfylt, og innenfor den oppgaven må du utføre en annen oppgave gjentatte ganger til en annen betingelse er oppfylt.
I en nestet while-løkke kjøres den ytre løkken én gang, og deretter vil den indre løkken kjøres hver gang den ytre løkken kjører. Den indre sløyfen utføres fullt ut én gang for hver iterasjon av den ytre sløyfen.
Eksempel
Følgende er eksempelkoden for bruk av Nested while loop i C++:
#includebruker navneområde std ;
int hoved- ( ) {
int Jeg = 1 ; // initialiser tellervariabelen til 1
// løkke mens tellervariabelen er mindre enn eller lik 3
samtidig som ( Jeg <= 3 ) {
int j = 1 ; // initialiser indre tellervariabel til 1
// løkke mens indre tellervariabel er mindre enn eller lik 3
samtidig som ( j <= 3 ) {
cout << Jeg << ' ' << j << ' \n ' ; // sender ut gjeldende verdier til tellervariablene
j ++; // øke indre tellervariabel
}
Jeg ++; // øke ytre tellervariabel
}
komme tilbake 0 ;
}
I denne koden kjører den ytre mens-løkken like lenge som Jeg blir lik 3, når verdien av Jeg blir større enn 3 vil sløyfen stoppe. Med hver ytre sløyfe-iterasjon, den indre telleren variabel j initialiseres til 1 og kjører den indre mens-løkken. Denne indre sløyfen vil løpe til verdien av j blir større enn 3 .
Inne i den indre sløyfen sender vi ut verdiene til Jeg og j . Etter det økte vi j . Dette fortsetter til den indre sløyfen har blitt utført tre ganger. Hver gang den ytre sløyfen økes, vil den indre sløyfen også bli utført på nytt.
Denne prosessen gjentas til den ytre løkken har blitt utført tre ganger og begge løkkene er ferdige. Utdataene fra denne koden er en tabell med verdier fra 1 1 til 3 3, som vist på bildet nedenfor.
C++ Uendelig mens Loop
I C++ er uendelig mens-løkker også mulig. En uendelig mens-løkke kjører kontinuerlig ettersom ingen definert betingelse kan være falsk. Det er bare én sann tilstand , dette gjør at while-løkken kan kjøres kontinuerlig i et uendelig antall ganger.
For eksempel , vil den nedenfor gitte løkken kjøres for alltid, og for å stoppe denne løkken må vi definere en break-setning på slutten av denne løkken.
samtidig som ( ekte ) {// kode som skal kjøres
}
En uendelig sløyfe kan være nyttig i noen tilfeller, for eksempel i innebygde systemer eller når du venter på brukerinndata.
Eksempel
Nedenfor er et eksempel på C++-programmet som kjører en uendelig mens-løkke i C++-kode:
#includebruker navneområde std ;
int hoved- ( ) {
int telle = 0 ;
samtidig som ( ekte ) {
cout << 'Infinitiv While Loop \n ' ;
telle ++;
hvis ( telle >= 10 ) {
gå i stykker ;
}
}
komme tilbake 0 ;
}
Den gitte koden lager en uendelig sløyfe som kontinuerlig sender 'Infinitive While Loop'-strengen til konsollen. Dette er fordi while-løkkens tilstand er satt til sann, som alltid er sann loop vil ikke ende.
For å stoppe en uendelig sløyfe, kan vi bruke break-setningen til å gå ut av sløyfen når en viss betingelse er oppfylt. I programmet ovenfor har vi satt maksimalt antall iterasjoner til 10, som kontrolleres av telle variabel og bruddsetningen.
Koden ovenfor vil kjøre uendelig mange ganger, men bruk av en break-setning vil stoppe den etter 10 iterasjoner.
Skrive ut partall og oddetall med while-løkke
Et annet eksempel på mens-løkker skriver ut partall og oddetall. For eksempel , bruker følgende gitte kode en while-løkke i C++ for å gi partall fra 2 til 10.
#includebruker navneområde std ;
int hoved- ( ) {
int Jeg = 2 ; // initialiser tellervariabelen til 2
// løkke mens tellervariabelen er mindre enn eller lik 10
samtidig som ( Jeg <= 10 ) {
cout << Jeg << endl ; // gi ut gjeldende verdi av tellervariabelen
Jeg += 2 ; // øke tellervariabelen med 2
}
komme tilbake 0 ;
}
Denne C++-koden initialiserer en tellervariabel Jeg til 2 og bruker en while-løkke til gjentatte ganger å sende ut verdien av Jeg så lenge den er mindre enn eller lik 10. For hver iterasjon av løkken øker den Jeg med 2. Hver gang sløyfen kjører vil utdata bli skrevet ut på terminalen. Etter at løkken er fullført, returnerer programmet 0 for å indikere vellykket utførelse.
På samme måte kan vi også trykke merkelig tall fra 1 til 9:
#includebruker navneområde std ;
int hoved- ( ) {
int Jeg = 1 ; // initialiser tellervariabelen til 1
// løkke mens tellervariabelen er mindre enn eller lik 9
samtidig som ( Jeg <= 9 ) {
cout << Jeg << endl ; // gi ut gjeldende verdi av tellervariabelen
Jeg += 2 ; // øke tellervariabelen med 2
}
komme tilbake 0 ;
}
I denne koden vil sløyfebetingelsen kjøre til tellervariabelen Jeg er mindre enn eller lik 9. Den cout setningen inne i loopen gir ut gjeldende verdi av Jeg , og deretter Jeg variabelen økes med 2 ved å bruke i += 2 uttalelse. Dette sikrer at bare oddetall skrives ut av løkken.
På slutten av programmet brukes en retursetning for å indikere at main()-funksjonen er fullført.
Konklusjon
En while-løkke er en kontrollstruktur som kjører et program så lenge den definerte betingelsen er sann. Her har vi dekket den grunnleggende syntaksen og eksempler på bruk av while-løkker i C++. Vi beskriver også hvordan man bruker en while-løkke i nestet form og hvordan man kan kjøre while-løkke et uendelig antall ganger. For mer informasjon om C++ while loop, les artikkelen.