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

Okay, before this gets too heated, why not settle it with a poll?

See my grand 'goto' poll thread.

Quote:

---

Originally posted by j0nas
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.

---

This I definitly disagree with. Goto has less semantics than for, while and return. Gotos can be used to do every loop construct, return statement, breaking out of loops and ifs, etc. Basically, the essence of goto is that it can mean anything. If it means something in particular to you, fine, but don't be surprised if it means something completely different to somebody else.

In my programs, I never have 8 levels of indentation, and I think it's not hard avoiding this without resorting to gotos.

Quote:

---

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...

---

No, I was in a conference he was holding in Eindhoven when somebody asked about the paper and his goto comment. He sort of joked that gotos were the worst thing anybody could have invented. But he still stood by his idea that goto was not a good idea.

By the way, Pascal (at least TPP) also includes goto, so I wonder why it's cited as a 'goto-hater' language.

I have a question, please help me...
Are goto in structured programming languages and Jump in Assembly the same ?
If I use goto in my application, and I debug to see its Assembly machine code, does it look like Jump ???
I ask this because in Assembly as I just learnt, the while/for loop is just represented by Jump and if we want to go to somewhere, we just keep jumping in and then if the condition is not satisfied, we jump out...That s why I wonder...

I dont know how to debug to see program machine code, i dont know, true ! Would you please do that and answer my questions ? Can you also teach me how to debug my program to see its assemply code (I am dumb, so, please tell me from scratch if you think you like to do that for me as a favor)

Thanks so very much....:)

Quote:

---

Originally posted by John E
Okay, before this gets too heated, why not settle it with a poll?

See my grand 'goto' poll thread.

---

Please donot misunderstand, I ask in this thread because my questions have no relations to your poll, but I did vote for REGULARLY USE GOTO(though I actually ALWAYS use it) because I want to finish my program as soon as possible....No matter how the end will be...:)

Quote:

---

Originally posted by Charleston
If I use goto in my application, and I debug to see its Assembly machine code, does it look like Jump ???

---

I'm not an expert in Assembler but I'd assume that a goto instruction would be implemented via a 'jmp' in the majority of cases.

Quote:

---

Originally posted by Charleston
Are goto in structured programming languages and Jump in Assembly the same ?

---

No, not really. 'jmp' can be used with other high level instructions, apart from 'goto'. For example, loops can use 'jmp' as you've already noticed. In fact, even functions are sometimes called using the 'jmp' statement, as opposed to 'call'.

Quote:

---

Originally posted by Charleston
Are goto in structured programming languages and Jump in Assembly the same ?
If I use goto in my application, and I debug to see its Assembly machine code, does it look like Jump ???

---

Structured programming is language independent. The idea is that you impose on yourself to only use certain control structures with special properties. In assembly language you certainly will need to use jumps to implement those control structures, for example the if-then-else. In a high level language you wont because the if-then-else is part of the language. The conclussion is that high level languages support structured programming better than assembly. In assembly language you'll have to see to it yourself that you follow the principles of structured programming

So it's not jumping in itself that's considered bad. It's the undiciplined, unrestriced jumping all over the place that makes the program complex and thereby error-prone.

Quote:

---

I dont know how to debug to see program machine code, i dont know, true ! Would you please do that and answer my questions ? Can you also teach me how to debug my program to see its assemply code (I am dumb, so, please tell me from scratch if you think you like to do that for me as a favor)

---

This is not a language question. It's a compiler/debugger specific question. Ask this question at a compiler oriented forum.

Thanks John and uj alot..

_uj, I will follow your advice... True, :)

As far as the language is concerned, right use of gotos is OK but when it comes to code readibility and maintenance, gotos are worst programming structure to use. In my opinion gotos are only usefull for machine generated code. In all other situations, their use should be avoided.

Quote:

---

Originally posted by j0nas
There's nothing wrong with using GOTOs--if used with care. I’m getting fed up on why always academic people complain about it.

---

It seems to be half Ivory Tower talking, cut off from the real world, and half '60's assembly programmer leftover talking about their old problems.

In some languages, like pre-Visual Basic (no block structure or true function definitions) GOTO's were the only way to go, and it was hard to maintain things correctly. You formed your if-then-else by using GOTO as jump points.

It's quite reasonable for complex code to do something like this:

Code:

---

(Open file)

(Work with file)
Many such tests as
if (some problem)
    goto CLOSE_FILE_AND_EXIT;

blah blah blah

if (some problem #73)
    goto CLOSE_FILE_AND_EXIT;

blah blah blah

CLOSE_FILE_AND_EXIT:
if (file is open)
    (close file);

---

If you can't do this, then you have to embedd clunky closes and returns everywhere, or have some method of setting a variable to bail out of code after the error is detected. This can get VERY ugly in non-trivial, real world cases.



C++ should have implemented LISP's "unwind-protect" operator for just such a situation. It allows you to specify a chunk of code to execute if anything called within the unwind-protect bails out for any reason (error thrown, return, etc.) In fact, C++'s try/throw/catch refuse seems to ape this poorly.


Actually, LISP should have been the language of the Internet, not Java, but that's another religious battle for another day...