wikiwand.com

Do while loop - Wikiwand

This section's factual accuracy is disputed. (November 2020)

These example programs calculate the factorial of 5 using their respective languages' syntax for a do-while loop.

Ada

with Ada.Integer_Text_IO;
procedure Factorial is
    Counter   : Integer := 5;
    Factorial : Integer := 1;
begin
    loop
        Factorial := Factorial * Counter;
        Counter   := Counter - 1;
        exit when Counter = 0;
    end loop;
    Ada.Integer_Text_IO.Put (Factorial);
end Factorial;

BASIC

Further information: BASIC

Early BASICs (such as GW-BASIC) used the syntax WHILE/WEND. Modern BASICs such as PowerBASIC provide both WHILE/WEND and DO/LOOP structures, with syntax such as DO WHILE/LOOP, DO UNTIL/LOOP, DO/LOOP WHILE, DO/LOOP UNTIL, and DO/LOOP (without outer testing, but with a conditional EXIT LOOP somewhere inside the loop). Typical BASIC source code:

Dim factorial As Integer
Dim counter As Integer
factorial = 1
counter = 5
Do
    factorial = factorial * counter
    counter = counter - 1
Loop While counter > 0
Print factorial

C, C++, D

int counter = 5;
int factorial = 1;
do {
    factorial *= counter--; // Multiply, then decrement.
} while (counter > 0);
std::println("factorial of 5 is {}", factorial);

Do-while(0) statements are also commonly used in C macros as a way to wrap multiple statements into a regular (as opposed to compound) statement. It makes a semicolon needed after the macro, providing a more function-like appearance for simple parsers and programmers as well as avoiding the scoping problem with if. It is recommended in CERT C Coding Standard rule PRE10-C.^[1]

Fortran

With legacy Fortran 77 there is no DO-WHILE construct but the same effect can be achieved with GOTO:

      INTEGER CNT,FACT
      CNT=5
      FACT=1
    1 CONTINUE
      FACT=FACT*CNT
      CNT=CNT-1
      IF (CNT.GT.0) GOTO 1
      PRINT*,FACT
      END

Fortran 90 and later supports a DO-While construct:

program FactorialProg
    integer :: counter = 5
    integer :: factorial = 1
    factorial = factorial * counter
    counter = counter - 1
    do while (counter /= 0)
        factorial = factorial * counter
        counter = counter - 1
     end do
    print *, factorial
end program FactorialProg

Java

int counter = 5;
int factorial = 1;
do {
    factorial *= counter--; // Multiply, then decrement.
} while (counter > 0);
System.out.println("The factorial of 5 is " + factorial);

Pascal

Pascal uses repeat/until syntax instead of do while.

factorial := 1;
counter := 5;
repeat
   factorial := factorial * counter;
   counter := counter - 1; // In Object Pascal one may use dec (counter);
until counter = 0;

PL/I

Further information: PL/I

The PL/I DO statement subsumes the functions of the post-test loop (do until), the pre-test loop (do while), and the for loop. All functions can be included in a single statement. The example shows only the "do until" syntax.

declare counter   fixed initial(5);
declare factorial fixed initial(1);
do until(counter <= 0);
    factorial = factorial * counter;
    counter = counter - 1;
end;
put(factorial);

Python

Python does not have a DO-WHILE loop, but its effect can be achieved by an infinite loop with a breaking condition at the end.

factorial = 1
counter = 5
while True:
    factorial *= counter
    counter -= 1
    if counter < 1:
        break
print(factorial)

Racket

In Racket, as in other Scheme implementations, a "named-let" is a popular way to implement loops:

#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
    (set! factorial (* factorial counter))
    (set! counter (sub1 counter))
    (when (> counter 0) (loop)))
(displayln factorial)

Compare this with the first example of the while loop example for Racket. Be aware that a named let can also take arguments.

Racket and Scheme also provide a proper do loop.

(define (factorial n)
    (do ((counter n (- counter 1))
        (result 1 (* result counter)))
    ((= counter 0) result) ; Stop condition and return value.
    ; The body of the do-loop is empty.
    ))

Smalltalk

| counter factorial |
counter := 5.
factorial := 1.
[counter > 0] whileTrue:
    [factorial := factorial * counter.
    counter := counter - 1].
Transcript show: factorial printString