when should I use do-while, while, for or even goto?

I've been coding in C++ for a while; unfortunately, till this very moment I am still clueless about the differences between all the types of loops.

All I've been told is that don't use goto. (but, to be honest, I have no idea why shouldn't I use this one)

I am also aware of the fact that 'while' loop tests its condition before execution of the contents of the loop begins; the 'do' loop tests it condition after it's been executed at least once.

I heard that sometimes you should use a certain type of loops to optimize the program, but, again, I have no idea when and why.

I would really appreciate if somebody could explain the differences to me. :confused:


Regards, :wave:
Richard

Never use goto. Goto jumps to different areas of your source code and can cause some serious source code following problems, not to mention it can screw up alot of things when compiled in very complex goto situations (instead of having 5 for loops, have 10 gotos. That would be a ***** to maintain and probably wouldn't be correct at the first go, thus execution problems).

Do loops, in my opinion, are just worthless. I have yet to find any reason to use a Do loop over a simple while or for loop. I also find Do loops confusing in large chunks of code, where as while and for loops just seem to flow correctly.

I think it comes down to style and readability. All of them will perform looping so if you only had one form to use you could still write every program you wanted.

Conventional wisdom says never to use GOTO. As far as I can tell, it is a throwback to the language BASIC (or beyond!) which probably everyone back in the old days cut their teeth on, I know I did. GOTO is the equivalent of an assembly language jump statement. It's just hard to read code that jumps to named tags because everytime you pass a tag you have to say to yourself, "ok, something is going on here, let me scroll down and find the matching GOTO statement." Those were horrible days to look back at now(freaking line numbers in your code!).

I find that if you need to iterate over a collection, array, objects, use a FOR statement. It closely matches the english language you might use in psuedocode. It is a rough translation of For Each Object in Collection as I see it.

Again with the psuedo code, WHILE and DO/WHILE. For readability, if you need to DO Something before you check your bailout condition.... Think about what your psuedo code would say and most the time which one to use just falls into place.

I find that DO/While loops are rare unless you are stepping an iterator of a collection in the While parameter part and you need to also process the first element of that collection.

along with the other comments, we've discussed this in various threads. I can't find the LONG goto thread right now via search...and I guess I'd rather not drudge that one up...better to let it die...but here is one...


http://www.codeguru.com/forum/showth...o&pagenumber=5

Okay, I think asnwering your questions is hard to newb like me, there is nothing much said in the Standard about those loop controls, but only their definitions, and how they work,
Those questions can still be answered by experienced programmers here.

Though some of the ideas above already mentioned the Goto statement, and I still wonder if it is still good to be in use in some situations. In the Standard, it is one of the Jump Statements and unconditionally transfers control to the statement labeled by the identifier located in the current function.
However, this kind of transfering is far different from the some kinds of terminated functions like abort(), exit() which will help you to run out of the scope/loops without destroying any objects created and it is a bad ideas to use them~Paul McKenzie.

And for me, I think it still depends on the particular problems and particular situations in which I will choose whether to use goto or not. For example, if i just jump a little, I mean not leaving so many code snippets unresolved in the program, I will psych up myself muster up all of my courages to make a jump outta them at once :)

All in all, only specific problems and paticular situations can lead you to the best choice so that you can make a distinction between when, where and how to use them...

The luckiest thing in reality,however, is that right on these boards there are many experienced gurus who I think can give you more ideas about all those control loops and such a jump statement as Joe Nellis already did. About his words accuracy, I have no comments, I dont know, true, because I am still a newb and correct or incorrect is only judged by many ideas from many people, not from an individual, so I will stay here listening only.

Another important point I would like to have a word about is that only hearing from one or two individuals doesnot mean you have to follow what they said, and as I already said, problems are or should be considered from many from different aspects. Two people might always have different views about one, exactly the same thing. I dont mean you have to follow my words, since making a choice is still one thing that belongs to you only..., it s just an idea anyway...

Quote:

---

Originally posted by Vietpub
All I've been told is that don't use goto. (but, to be honest, I have no idea why shouldn't I use this one)

---

Any program can be written without gotos using a few selected control structures. This is the central dogma of structured programming and the foundation of most popular high-level languages today.

Structured programming demands that you give up your freedom to jump back and forth all over the program and instead restrict yourself to just a few imposed movements like if-then-else and while-do etcetera. The advantage is that the complexity of the program is reduced. It becomes easier to write, read, debug and maintain, in short, it becomes simpler.

Structured programming was very controversial at first. Some felt restrained and said I'd go mad with this strait-jacket. Some saw the benefits and said I would rather kill myself than ever use a goto again. This happened in the 70's and among surviving programmers there's often a very strong sentiment to NEVER EVER USE GOTO.

But things have relaxed and the goto is basically back (if it ever left). I'm thinking of the break statement many languages allow to exit out of loops. The reason why this form of goto is less malign is that it's local. It's confined to a very limited section of code. It still increases structural complexity, BUT it at the same time reduces logical complexity. In plain words you make the loop exit criterium simpler but you trade it for an extra exit jump. I personally prefer a more complex loop structure over a gigant logical exit expression with lots of and's and or's.

In C++ you can just break out of the enclosing loop. You can't break straight out of nested loops. This is one situation when I think a well placed goto is motivated. If you jump out of the innermost loop to the exit point of the outermost loop you remove lots of loop exit checks. This would make your program simpler and that's the ultimate goal of structured programming so that should be allowed I think.

So in my view break, continue and well-placed locally confined gotos are okay even if structured programming affectionados will think otherwise I'm sure. :)

GOTO is evil

Edsger Dijkstra, sometime in an article

;)

goto is generally considered bad form. It kind of breaks the concept of top down design which was the way things were designed back before objects. Having said this though I've seen it used to make hardware dependent code more efficient. I've also seen it abused, but not lately because of the social and moral condemnation faced by anybody who trys to employ it.

For loop is just like a while loop only the increment, test, initial state of the index and now even the definition of the index are all contained in one line.



code:--------------------------------------------------------------------------------
for( int i = 0; i < 12; i++ )
{
// yada yada yada
}

// same as
int i = 0;

while ( i < 12 )
{
// yada yada yada

i = i + 1;
}
--------------------------------------------------------------------------------



Now do whiles are a little bit different...

A while tests at the beginning of your iteration. A 'do while' tests at the end of the iteration. They are logically different shades of the loop pigmentation. I think you could substitute a while for a do while or visa versa. I also think though that if you need an exact behavior for a loop options like do while can be very helpful and increase the readability and maintainability of your code.

there are basic rules that can guide you on this decision:
Use do-while when you have a repeation loop that wil happen at least one time, ex: in a keboard input, the user must press at least one key :

Code:

---

do
{
  key = getchar();
  .....

}while(key != ENTER);

---

Use while on loops that can never happen ex:

Code:

---

input a;
input b;

while (a < b)
{
  a = a +1;
  ...
  c++;
}

---

Use for when you know the number of times that the loop will happen ex:

Code:

---

input a;
input b;

if (a < b)
{
  z = b-a;

  for (int i = 0 ; i < z ; i++)
  {

      ......
  }
}

---

for is a very flexible structure and you can use it in any of the cases before because its condition is a while, so its the same of

for (int i = a ; "while (i < b)" ; i++) ...

Never use goto, all branching possibles you can solve using one of the loop structures, or mixing them.


regards

Rabelo

Quote:

---

Originally posted by kasracer
Never use goto

---

Quote:

---

Originally posted by Yves M
GOTO is evil

---

Quote:

---

Originally posted by Rabelo
all branching possibles you can solve using one of the loop structures, or mixing them.

---

Hmm.... I'm inclined to agree in theory but, as Sean Connery once said, "never say never." I once used goto to implement a Check macro and it vastly improved the readability of the code. In fact, I doubt that it could have been implemented without goto. Having said that, I think that's the only occasion I've needed it in many years of programming.

goto suffers from bad publicity because it's much too easy to misuse. I can still remember some assembly language programs I saw with crossed loops and all sorts of nasties caused by goto.

I'd never, never, never recommend it for looping - but like everything else, if it's used in the right context....

- and sensibly....

- and sparingly....

__________________________________________________
Postscript: - Of course, no one said Sean Connery was ever a great programmer...! :D ;)

Quote:

---

Originally posted by Yves M
GOTO is evil

Edsger Dijkstra, sometime in an article

;)

---

There's nothing wrong with using GOTOs--if used with care. I’m getting fed up on why always academic people complain about it. Dijkstra's paper on structured programming is fine, but it is also very very old. The world has changed.

If you know what you do, and if it helps getting your code better/cleaner, do it with GOTOs... Let's be pragmatic! :thumb:

Maybe there are some cases when gotos are better (finite state machines could be an example), but personally, I can only repeat what I said in the other goto post.

Goto doesn't have any semantics, it doesn't mean anything. It can be used for if statements, loop breaking, looping, random jumping around, code cleanup... And since it's easier to read code where the semantics are clear, it's better to always prefer the solution that carries semantics. Only if there is no such solution (or it's even more 'unreadable', whatever that means), then a goto is justified.

Quote:

---

I’m getting fed up on why always academic people complain about it. Dijkstra's paper on structured programming is fine, but it is also very very old. The world has changed.

---

Well, my previous comment was meant as a satire (he didn't really say 'goto is evil' ;) ) of what had been the basis of a heated discussion already 30 years ago. That being said, I still agree with his goto comment. Some things don't lose truth in 30 years.

Quote:

---

Originally posted by Yves M
Maybe there are some cases when gotos are better (finite state machines could be an example), but personally, I can only repeat what I said in the other goto post.

---

I won't state goto:s' pro's and con's--I skilled programmer knows when to use goto. Period.

Quote:

---

Originally posted by Yves M
And since it's easier to read code where the semantics are clear, it's better to always prefer the solution that carries semantics. Only if there is no such solution (or it's even more 'unreadable', whatever that means), then a goto is justified.

---

First, the semantics for goto:s are very clear. Secondly, it's a lot easier to follow a simple goto statement than 6 or 8 levels of indented code.

Quote:

---

Originally posted by Yves M
Well, my previous comment was meant as a satire (he didn't really say 'goto is evil' ;) ) of what had been the basis of a heated discussion already 30 years ago.

---

I understood that your "goto is evil"-statement wasn't directly quoted from Dijkstra's work. You have probably heard it in some stupid:p CS course. Probably when learning Pascal...

Quote:

---

Originally posted by Yves M
That being said, I still agree with his goto comment. Some things don't lose truth in 30 years.

---

Yepp, some things can stand the truth in 30 years, but not his goto-comments.

I'm being slightly sarcastic in my answers, so please don't take this "matter of taste" topic too seriously. ;)

/Jonas

Thinking on C or C++, I have never seen a branching condition that I couldn´t solve with the loop structures. This on the real world, on academic world there are always problems with no soluction. The real problem is not with goto statement, is on the label: The label is a door opened for all te other lines of the program, causing loose of structure. It can transform your program on a wired and confused set of instructions. the label line is able to be the next line of any other line of you program. The programs on the real world are dynamic: you are always improving it, fitting it on the real world changes. Then if you use goto as a soluction, by the time, you program can become a monster. Other people will work on your program so you have to be clear. Beside this, if you can use goto instead all other programing structures (for ,while, switch....), so why are they for? if goto can do the job, why use these structures???. For clarness, Any programer is able to undestand any while structure on a minute, beside this, to undestand some goto structure, you can spend hours.
If goto is the only solution, then you may step down to assembler...

Rabelo

Quote:

---

Originally posted by Rabelo
Thinking on C or C++, I have never seen a branching condition that I couldn´t solve with the loop structures. This on the real world, on academic world there are always problems with no soluction. The real problem is not with goto statement, is on the label: The label is a door opened for all te other lines of the program, causing loose of structure. It can transform your program on a wired and confused set of instructions. the label line is able to be the next line of any other line of you program. The programs on the real world are dynamic: you are always improving it, fitting it on the real world changes. Then if you use goto as a soluction, by the time, you program can become a monster. Other people will work on your program so you have to be clear. Beside this, if you can use goto instead all other programing structures (for ,while, switch....), so why are they for? if goto can do the job, why use these structures???. For clarness, Any programer is able to undestand any while structure on a minute, beside this, to undestand some goto structure, you can spend hours.
If goto is the only solution, then you may step down to assembler...
Rabelo

---

Yet another "'goto is evil" opinion.

Come on now, let's drop this subject about goto or not goto... No one will ever win this fight... It is all about taste...

I will continue to use goto when needed.

Happy hacking,
Jonas