Anbefalet, 2021

Redaktørens Valg

Forskel Mellem mens og gør-mens Loop

Iteration udsagn gør det muligt at sætte instruktioner til at udføre gentagne gange, indtil tilstanden ikke viser sig falsk. Iteration udsagnene i C ++ og Java er, for loop, mens loop og gøre mens loop. Disse udsagn kaldes almindeligvis sløjfer. Her er den væsentligste forskel mellem en tidsløkke og en gangsløjfe, at mens lusekontrolstilstanden før lukningens sløjfe kontrollerer tilstanden efter udførelsen af ​​udsagnene inde i sløjfen.

I denne artikel skal vi diskutere forskellene mellem "while" loop og "do-while" loop.

Sammenligningstabel

Grundlag for sammenligningmensgøre imens
Generel Formularmens (betingelse) {
udsagn; // kropsløjf
}
gøre {
.
udsagn; // kropsløjf.
.
} mens (tilstand)
KontrolbetingelseI 'while' loop vises den kontrollerende tilstand ved starten af ​​løkken.I 'do-while'-løkken vises den styrende tilstand i slutningen af ​​sløjfen.
gentagelserIterationerne forekommer ikke, hvis tilstanden ved den første iteration forekommer falsk.Iterationen sker mindst en gang, selvom tilstanden er falsk ved den første iteration.

Definition af mens Loop

Den tidsløkke er den mest grundlæggende loop tilgængelig i C ++ og Java. Arbejdet af en tidssløkke er ens i både C ++ og Java. Den generelle form for while loop er:

 mens (tilstand) {udsagn; // kropsløkke} 

Mens løkken først verificerer tilstanden, og hvis tilstanden er sand, så det itererer sløjfen, indtil tilstanden viser sig at være falsk. Tilstanden i mens løkken kan være et hvilket som helst booleskt udtryk. Når udtryk returnerer en værdi, der ikke er nul, er tilstanden "sand", og hvis et udtryk returnerer en nulværdi, bliver tilstanden "falsk". Hvis tilstanden bliver sand, genoptages lus selv, og hvis tilstanden bliver falsk, går kontrollen til den næste linje i koden umiddelbart efterfulgt af sløjfen.

Opgørelserne eller loopens krop kan enten være en tom sætning eller en enkelt erklæring eller en blok af udsagn.

Lad os diskutere arbejdet med en tidssløkke. I eksemplet nedenfor udskrives koden fra 1 til 10.

 // eksempel er i Java. klasse mens {public static void main (args []) {int n = 0; mens (n ​​<= 10) {n ++; system.out.println ("n =" + n); }}} // output n = 1 n = 2 n = 3 n = 4 n = 5 n = 6 n = 7 n = 8 n = 9 n = 10 

Her er den indledende værdi af 'n' 0, som ændrer tilstanden i løbet slynge sande. Kontrollen kommer så ind i kroppen af ​​mens loop og værdien af ​​'n' øges i henhold til den første sætning i kroppen af ​​en tidssløkke. Derefter udskrives værdien af ​​'n', og igen går kontrollen tilbage til tilstanden af ​​en tidsløkke, nu er værdien af ​​'n' 1, som igen opfylder betingelsen, og loopens krop udføres igen.

Dette fortsætter indtil betingelsen er sand, så snart tilstanden bliver falsk, afsluttes sløjfen. Ligesom for sløjfe kontrollerer samtidig sløjfen også først betingelsen og udfører derefter sløjfekroppen.

Definition af do-while Loop

Som i løbet af en loop, hvis den kontrollerende tilstand kun bliver falsk i den første iteration, bliver kroppen af ​​den mellemliggende loop ikke udført overhovedet. Men runde-sløjfen er noget anderledes end under løkken. Do-while-løkken udfører sløjfens krop mindst en gang, selvom tilstanden er fejlagtig ved første forsøg.

Den generelle form for do-while er som følger.

 gør {. udsagn // sløjfe. . } mens (tilstand) 

I en do-while-loop forekommer sløjfens krop før den kontrollerende tilstand, og den betingede erklæring er i bunden af ​​sløjfen. Som i løbet af sløjfen, her kan også sløjfens krop være tom, da både C + + og Java tillader null udsagn, eller der kan kun være en enkelt sætning eller en blok af udsagn. Tilstanden her er også et booleskt udtryk, hvilket er sandt for alle ikke-nulværdier.

I en do-while-loop når kontrollen først til erklæringen i kroppen af ​​en do-while-loop. Erklæringerne i kroppen udføres først og derefter når kontrollen til tilstanden af ​​løkken. Tilstanden er verificeret, og hvis det er sandt, er sløjfen itereret igen, og hvis tilstanden er fejlagtig, fortsætter kontrollen til næste linje umiddelbart efter sløjfen.

Lad os forstå det ved at implementere ovenstående eksempel i løbetid.

 // eksempel er i Java. klasse mens {public static void main (args []) {int n = 1; gør {system.out.println ("n =" + n); n ++; } mens (n ​​<10)}} // output n = 1 n = 2 n = 3 n = 4 n = 5 n = 6 n = 7 n = 8 n = 9 n = 10 

Her genoptages værdien af ​​n = 1 styringen til loopens krop, værdien af ​​'n' udskrives, og derefter øges værdien. Derefter genoptages kontrollen til tilstanden af ​​do-while-sløjfen; betingelsen er verificeret, som viser sig sandt for n = 1, så sløjfen er iterat igen og fortsæt til tilstanden bliver falsk.

Nøgleforskelle mellem mens og gør-mens loop

  1. Mens sløjfen kontrollerer tilstanden ved start af sløjfen, og hvis tilstanden er tilfredsstillet erklæring inde i sløjfen, udføres. I tilstanden med mellemrum slettes tilstanden efter udførelsen af ​​alle udsagn i loopens krop.
  2. Hvis tilstanden i et tidssløjfe er falsk, udføres ikke en enkelt sætning inde i sløjfen, og hvis tilstanden i "do-while" -sløjfen er falsk, udføres også sløjfens krop mindst én gang, så tilstanden testes.

Konklusion:

Både mens og undertiden er iterationsopgørelsen, hvis vi ønsker det først, skal tilstanden verificeres, og så skal udsagnene inde i sløjfen udføres, så mens sløjfen bruges. Hvis du vil teste opsigelsestilstanden i slutningen af ​​sløjfen, bruges do-while-sløjfen.

Top