When is a do-while appropriate?

Question

When is a do-while the better choice over other types of loops? What are some common scenarios where its better than others?

I understand the function of a do-while, but not when to use it.

Answer 1

When you need something done at least once, but don't know the number of times prior to initiating the loop.

Answer 2

It's not often that it's the best thing to use, but one scenario is when you must do something at least once, but any further iterations are dependent on some condition.

do {
    //do something
} while ( condition );

Answer 3

When it is more appropriate to do something and then evaluate the boolean expression...or as Brian said...when you need something done at least once. This syntax moves the evaluation of the boolean expression to after the loop instead of before the loop.

Answer 4

It's appropriate when you would like to have your condition checked at the end of the loop execution. Hence the loop will always run at least once and then it will verify if it should iterate further.

Answer 5

Whenever what is in the loop needs to be executed at least once.

Answer 6

I've long held that do-while is not used in C-based languages as much as it should be because the reuse of the "while" keyword is awkward and confusing. Pascal's repeat-until does not share any keywords with its while-begin-end structure.

I'd love to analyze a big heap of code someday and see if do-while is underrepresented in C code compared to similar constructs in other languages.

Answer 7

I've used it before if I need to implement lots of conditional checks, for example processing an input form in php. Probably not the best practice, but it's more readable than many alternatives:

do {
   if ( field1_is_invalid ) {
      $err_msg = "field1 is invalid"; break;
   }

   if ( field2_is_invalid ) {
      $err_msg = "field2 is invalid"; break;
   }

   .. check half a dozen more things ..

   // Only executes if all checks succeed.
   do_some_updates();

} while (false)

Also, I guess this isn't technically a loop. More like a way of avoiding using GOTO :)

Answer 8

In some languages at least, you don't have to have the while() statement at the end of the loop. For example,

do 
    ....
while(test)
    ....
repeat

is a structure I find myself using occasionally. Sometimes it makes more sense formatting-wise to do it this way; I work in a database-centric language most of the time, where all the fields are simply separated by an iterator - meaning if a record exists, there is always at least one field. This structure works well for parsing that data. First, I navigate to the location of the data, have a while(data exists), and then process the data; then I loop back to the beginning.

For the curious, it's PICK DATA/Basic. (I had an example written in C, but apparently it doesn't compile as I thought. Sorry, C folks... You can always emulate the behavior with a break statement, though I can't really suggest it for readability reasons.)

Answer 9

do while() loops while a condition is true, but on the other hand, Pascal's repeat until loops while a condition is false (both will run at least once).

When I program in Pascal I almost always use repeat until.
When I program in C++ I almost always use while() {}.

I can't explain why, but I feel it's normal. Weird?

Answer 10

I usually use a do-while when something needs to happen, but it won't necessarily happen "correctly" on the first time. For instance:

int x;
do
{
    x = random.next(100);
    cout << x << endl;
} while (x != 13);

In this case, the x you start with doesn't matter at all, because it's overwritten.

Answer 11

when reading from a file or waiting for a connection to be established (other human interaction as well), anything for what the number of iterations is not known a priori (e.g. number of records returned by an sql query), or when you do steps of different size (e.g. read 1 or 5 lines from the file depending on the last one read), when going over all combinations/permutations of objects, whenever 'for' loop conditions become cumbersome

Answer 12

No-one's yet mentioned its use in C macros...

#define do_all(x) do{ foo(x); bar(x); baz(x); } while(0)

then in the code you can have

do_all(a);

• the point being that it gets executed exactly once and the semi-colon on the end of the macro call completes the while(0); statement.