Anbefalt, 2024

Redaksjonens

Forskjellen mellom mens og gjør-mens Loop

Iteration-setninger tillater at sett med instruksjoner utføres gjentatte ganger til tilstanden ikke viser seg falsk. Iterasjonsprosedyrene i C ++ og Java er, for loop, mens loop og gjør mens loop. Disse utsagnene kalles vanligvis løkker. Her er hovedforskjellen mellom en stundsløyfe og en gangsløyfen at mens sløyfekontrolltilstanden før lukning av sløyfen, mens mens-sløyfen kontrollerer tilstanden etter utførelsen av utsagnene inne i sløyfen.

I denne artikkelen skal vi diskutere forskjellene mellom "while" loop og "do-while" loop.

Sammenligningstabel

Grunnlag for sammenligningsamtidig somgjør mens
Generell skjemamens (tilstand) {
uttalelser; // sløyfe
}
gjøre{
.
uttalelser; // sløyfe.
.
} mens (betingelse);
Kontrollerende tilstandI "while loop" vises kontrollerende tilstand ved begynnelsen av løkken.I "do-while" -løkke vises kontrollerende tilstand på slutten av løkken.
gjentakelserIterasjonene forekommer ikke dersom tilstanden ved den første iterasjonen virker falsk.Iterasjonen skjer minst en gang, selv om tilstanden er feil ved den første iterasjonen.

Definisjon av mens Loop

Mens sløyfen er den mest fundamentale sløyfen som er tilgjengelig i C ++ og Java. Arbeidet med en stundsløyfe er lik både i C + + og Java. Den generelle formen for while loop er:

 mens (tilstand) {uttalelser; // sløyfe 

Samtidig sløyfen verifiserer først tilstanden, og hvis tilstanden er sant, det deterer løkken til tilstanden viser seg å være feil. Tilstanden i mens løkken kan være noe boolesk uttrykk. Når uttrykket returnerer en verdi som ikke er null, er tilstanden "sant", og hvis et uttrykk returnerer en null-verdi, blir tilstanden "falsk". Hvis tilstanden blir sant, slår det seg igjen, og hvis tilstanden blir feil, går kontrollen til neste linje av koden umiddelbart etterfulgt av løkken.

Utsagnene eller sløyfens kropp kan enten være en tom setning eller en enkelt setning eller en blokk med setninger.

La oss diskutere arbeidet med en stundsløyfe. I eksemplet nedenfor skrives koden fra 1 til 10.

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

Her er den opprinnelige verdien av 'n' 0, som gjør tilstanden i mens sløyfen er sann. Kontrollen kommer da inn i kroppen mens loop og verdien av 'n' økes i henhold til den første setningen i kroppen av en stundsløyfe. Deretter skrives verdien av 'n', og igjen går kontrollen tilbake til tilstanden av en stundsløyfe, nå er verdien av 'n' 1 som igjen tilfredsstiller tilstanden, og sløyfens kropp utføres igjen.

Dette fortsetter til tilstanden er sant, så snart tilstanden blir falsk, avsluttes sløyfen. Som for sløyfen kontrollerer samtidig sløyfen først tilstanden og utfører sløyfelegemet.

Definisjon av gjør-mens Loop

Som i løpet av en løkke, hvis den kontrollerende tilstanden blir falsk i den første iterasjonen, blir ikke kroppens mellomløp utført i det hele tatt. Men løpebåndet er noe annerledes enn mens løkken er. Do-while-sløyfen utfører sløyfens kropp minst en gang, selv om tilstanden er feil ved første forsøk.

Den generelle form for gjør-mens er som følger.

 gjør {. uttalelser // sløyfe. . } mens (betingelse); 

I løpet av en gangsløyfe opptrer sløyfens kropp før den kontrollerende tilstanden, og den betingede utsagnet er i bunnen av sløyfen. Som i mens sløyfe, her kan også kroppens sløyfe være tomt, ettersom både C + + og Java lar null setninger, eller det kan bare være en enkelt setning eller en blokk med setninger. Forholdet her er også et boolesk uttrykk, som er sant for alle ikke-nullverdier.

I en stund-løkke når kontrollen først til setningen i kroppen av en gang-mens-sløyfe. Utsagnene i kroppen blir utført først, og deretter kommer kontrollen til tilstanden av sløyfen. Tilstanden er verifisert, og hvis det er sant, sløyfes det igjen, og hvis tilstanden er feil, så går kontrollen tilbake til neste linje umiddelbart etter løkken.

La oss forstå det ved å implementere over eksempel i løpet av tiden.

 // eksempel er i Java. klasse mens {offentlig statisk tomrom main (args []) {int n = 1; gjør {system.out.println ("n =" + n); n ++; } mens (n ​​<10)}} // utgang n = 1 n = 2 n = 3 n = 4 n = 5 n = 6 n = 7 n = 8 n = 9 n = 10 

Her gjenoppretter verdien av n = 1 kontrollen til sløyfens kropp, verdien av 'n' skrives ut og deretter økes verdien. Derefter gjenopptas kontrollen til tilstanden til do-while-sløyfen; tilstanden er verifisert som viser seg sant for n = 1, så sløyfen er iterate igjen og fortsett til tilstanden blir falsk.

Nøkkelforskjeller mellom mens og gjør-mens løp

  1. Mens løkken kontrollerer tilstanden ved starten av løkken, og hvis tilstanden er tilfredsstillende, er innsatsen i løkken utført. I løpet av løpet, kontrolleres tilstanden etter utførelsen av alle utsagn i sløyfens kropp.
  2. Hvis tilstanden i en stundsløyfe er falsk, utføres ikke en enkelt setning inne i sløyfen, og hvis tilstanden i "do-while" -sløyfen er falsk, blir også sløyfens kropp utført minst en gang da tilstanden testes.

Konklusjon:

Både mens og undertiden er iterasjonserklæringen, hvis vi ønsker det først, må tilstanden verifiseres, og så må utsagnene inne i løkken utføres da mens løkken brukes. Hvis du vil teste oppsigelsestilstanden på slutten av sløyfen, benyttes sløyfe-sløyfen.

Top