Indholdsfortegnelse:
- Hvad er mens Loop i C++
- Syntaks for while Loop
- Sådan bruges, mens du looper i C++
- C++ Indlejret mens loop
- C++ Uendelig mens Loop
- Udskrivning af lige og ulige tal med while-løkker i C++
- Konklusion
Hvad er mens Loop i C++
En while-løkke er en kontrolstruktur, der fortsætter med at køre, så længe betingelsen evalueres til sand, og den stopper, når betingelsen bliver falsk. Det er nyttigt i tilfælde, hvor du ønsker at gentage en bestemt opgave, indtil en bestemt betingelse er opfyldt.
For eksempel , kan du bruge en while-løkke til at udskrive tal fra 1 til 10 eller beregne et givet tals fakultet.
Syntaks for while Loop
Den grundlæggende syntaks for en while-løkke i C++ er som følger:
mens ( tilstand ) {
// kode, der skal udføres
}
Koden i de krøllede parenteser vil blive udført gentagne gange, så længe betingelsen er sand. Tilstanden vil blive kontrolleret hver gang løkken kører.
Sådan bruges, mens du looper i C++
Et af de mest almindelige eksempler på mens-løkker tæller fra et startpunkt til et slutpunkt. For eksempel, følgende kode vil tælle fra 1 til 10:
#includebruger navneområde std ;
int vigtigste ( ) {
int jeg = 1 ; // initialiser tællervariabel til 1
// loop mens tællervariablen er mindre end eller lig med 10
mens ( jeg <= 10 ) {
cout << jeg << endl ; // output den aktuelle værdi af tællervariablen
jeg ++; // forøg tællervariablen
}
Vend tilbage 0 ;
}
Denne kode viser, hvordan man bruger en while-løkke i C++. Programmet initialiserer en tællervariabel jeg til 1 og udfører derefter en while-løkke, der fortsætter med at køre indtil jeg bliver større end 10.
Inde i while-løkken udskrives den aktuelle værdi af tællervariablen til konsollen ved hjælp af cout sætning efterfulgt af et linjeskift vha endl . Tællervariablen øges derefter med 1 ved hjælp af i++ udmelding.
Sløjfen fortsætter med at køre indtil tællervariablen jeg når en værdi på 11, hvorefter while-løkken afsluttes, og programmet afsluttes med en returværdi på 0.
C++ Indlejret mens loop
Mens løkkerne kan også være indlejret , hvilket betyder, at du kan have en while-løkke inde i en anden while-løkke. Dette er nyttigt i tilfælde, hvor du skal udføre en opgave gentagne gange, indtil en specifik betingelse er opfyldt, og inden for denne opgave skal du udføre en anden opgave gentagne gange, indtil en anden betingelse er opfyldt.
I en indlejret while-løkke udføres den ydre løkke én gang, og derefter udføres den indre løkke, hver gang den ydre løkke kører. Den indre løkke udføres fuldt ud én gang for hver iteration af den ydre løkke.
Eksempel
Følgende er eksempelkoden til brug af Nested while loop i C++:
#includebruger navneområde std ;
int vigtigste ( ) {
int jeg = 1 ; // initialiser tællervariabel til 1
// loop mens tællervariabelen er mindre end eller lig med 3
mens ( jeg <= 3 ) {
int j = 1 ; // initialiser indre tællervariabel til 1
// loop, mens den indre tællervariabel er mindre end eller lig med 3
mens ( j <= 3 ) {
cout << jeg << ' ' << j << ' \n ' ; // output de aktuelle værdier af tællervariablerne
j ++; // forøg indre tællervariabel
}
jeg ++; // øg ydre tællervariabel
}
Vend tilbage 0 ;
}
I denne kode kører den ydre mens-løkke lige så længe som jeg bliver lig med 3, når værdien af jeg bliver større end 3, stopper løkken. Med hver ydre sløjfe-iteration, den indre tæller-variabel j initialiseres til 1 og udfører den indre mens-løkke. Denne indre sløjfe vil køre indtil værdien af j bliver større end 3 .
Inde i den indre sløjfe udlæser vi værdierne af jeg og j . Derefter øgede vi j . Dette fortsætter, indtil den indre løkke er blevet udført tre gange. Hver gang den ydre løkke øges, vil den indre løkke også blive udført igen.
Denne proces gentages, indtil den ydre løkke er blevet udført tre gange, og begge løkker er afsluttet. Outputtet af denne kode er en tabel med værdier fra 1 1 til 3 3, som vist på billedet nedenfor.
C++ Uendelig mens Loop
I C++ er de uendelige mens-løkker også mulige. En uendelig mens-løkke kører kontinuerligt, da ingen defineret betingelse kan være falsk. Der er kun én sand betingelse , dette tillader while-løkken at køre uafbrudt i et uendeligt antal gange.
For eksempel , vil den nedenfor angivne løkke køre for evigt, og for at stoppe denne løkke er vi nødt til at definere en break-sætning i slutningen af denne løkke.
mens ( rigtigt ) {// kode, der skal udføres
}
En uendelig sløjfe kan være nyttig i nogle tilfælde, såsom i indlejrede systemer eller når man venter på brugerinput.
Eksempel
Nedenfor er et eksempel på C++-programmet, der kører en uendelig mens-løkke i C++-kode:
#includebruger navneområde std ;
int vigtigste ( ) {
int tælle = 0 ;
mens ( rigtigt ) {
cout << 'Infinitiv Mens Loop \n ' ;
tælle ++;
hvis ( tælle >= 10 ) {
pause ;
}
}
Vend tilbage 0 ;
}
Den givne kode skaber en uendelig loop, der kontinuerligt udsender 'Infinitive While Loop'-strengen til konsollen. Dette skyldes, at while-løkkens tilstand er sat til sand, som altid er sand, vil løkken ikke ende.
For at stoppe en uendelig løkke kan vi bruge break-sætningen til at forlade løkken, når en bestemt betingelse er opfyldt. I ovenstående program har vi sat det maksimale antal iterationer til 10, som styres af tælle variabel og break statement.
Ovenstående kode vil køre uendeligt mange gange, men brug af en break-sætning stopper den efter 10 iterationer.
Udskrivning af lige og ulige tal med while-løkke
Et andet eksempel på while-løkker udskriver lige og ulige tal. For eksempel , bruger den følgende givne kode en while-løkke i C++ til at udlæse de lige tal fra 2 til 10.
#includebruger navneområde std ;
int vigtigste ( ) {
int jeg = 2 ; // initialiser tællervariabel til 2
// loop mens tællervariabelen er mindre end eller lig med 10
mens ( jeg <= 10 ) {
cout << jeg << endl ; // output den aktuelle værdi af tællervariablen
jeg += 2 ; // forøg tællervariablen med 2
}
Vend tilbage 0 ;
}
Denne C++-kode initialiserer en tællervariabel jeg til 2 og bruger en while-løkke til gentagne gange at udlæse værdien af jeg så længe den er mindre end eller lig med 10. Ved hver iteration af sløjfen stiger den jeg med 2. Hver gang løkken kører, vil output blive udskrevet på terminalen. Når løkken er fuldført, returnerer programmet 0 for at indikere vellykket udførelse.
På samme måde kan vi også printe ulige tal fra 1 til 9:
#includebruger navneområde std ;
int vigtigste ( ) {
int jeg = 1 ; // initialiser tællervariabel til 1
// loop mens tællervariabelen er mindre end eller lig med 9
mens ( jeg <= 9 ) {
cout << jeg << endl ; // output den aktuelle værdi af tællervariablen
jeg += 2 ; // forøg tællervariablen med 2
}
Vend tilbage 0 ;
}
I denne kode vil sløjfebetingelsen køre indtil tællervariablen jeg er mindre end eller lig med 9. Den cout sætning inde i løkken udsender den aktuelle værdi af jeg , og derefter jeg variabel øges med 2 ved hjælp af i += 2 udmelding. Dette sikrer, at kun ulige tal udskrives af løkken.
I slutningen af programmet bruges en return-sætning til at angive, at main()-funktionen er fuldført.
Konklusion
En while-løkke er en kontrolstruktur, der kører et program, så længe den definerede betingelse er sand. Her har vi dækket den grundlæggende syntaks og eksempler på brug af while-løkker i C++. Vi beskriver også, hvordan man bruger en while-løkke i indlejret form, og hvordan man kan køre while-løkke et uendeligt antal gange. For flere detaljer om C++ while loop, læs artiklen.