goto question

today i was looking at a program online and i noticed the command goto, of which i was unfamiliar with. i now realize what it does and how it works, but when i asked my teacher why he hadn't taught us about it he said he learned back when he was in school that it was bad programming. he said he wasn't sure if this was true so i was wondering what are (if any) of the downsides of using this command.

thanks in advance

it is bad practice to jump around a subroutine with no rhyme or reason. This is what goto allows. There is a matter of program flow. Program flow can be beautiful if it goes through the basic loops and conditional statements and ends at the end of the function EVERY TIME. goto bypasses that system. It creates confusing code. While it is most definitely still valid, it should be avoided.

but assuming im careful it's ok... like no risk of memory leaks etc?

yes, if you are careful it is ok. It translates to a JMP assembler instruction which is of course what most of the other stuff eventually turns into anyway. However, most people would tell you not to use it anyway.

> like no risk of memory leaks etc?

That depends on your use. Consider this code:

Code:

---

  void somefunc()
  {
      MyClass* p = new MyClass;
      goto end;
      delete p;
    end:
      return;
  }

---

That code is obviously oversimplistic, and could be avoided by using a std::auto_ptr, but the main problem with goto is that you lose the predictability of your code.

However, I would never suggest to ban it's use outright. If you're writing the inner loop for an interpreter and you find that a goto can give you a 5-15% increase in speed (check out Ximian's Mono implementation of .Net), then there is no reason not to use it.

That said, for most situations, there is a more elegant solution than sticking indiscriminant jmps in your code.

-tf

Many programmers wouldn't touch a project with a goto statement.

There are well-structured programs, and then there's goto.

I recently participated in a regional programming competition sponsored by the ACM. The goal was to solve problems as quickly as possible, so that meant a lot of dirty coding rather that what is normally taught to programmers. I was the only on my team who knew had to properly use goto. Although we could've done without goto, doing so would've been much more difficult.

I'd never be the first to suggest using goto in a business or academic setting, though.

A truly good optimizing compiler should be able to negate any benefit you derive from goto.

I don't use it, ever, and it's not considered good practice. You can easily abuse it.

avoiding goto was one of the bigger accomplishments of languages like C++... your programming teacher should be familiar with the term 'spaghetti code'

Although I never use it, I'm glad it's part of the language. :)

I book marked this page for when this debate next came up.
http://www.azillionmonkeys.com/qed/goto.html

I use it all the time in C to roughly emulate structured exception handling and you will see it fairly often around the place in this use.

Quote:

---

http://www.azillionmonkeys.com/qed/goto.html

---

I'm gonna make this my signature!!!

gg

Did it work?

gg

[EDIT]
Woo hoo!

spaghetti code mon!

Quote:

---

Originally posted by anonytmouse
I book marked this page for when this debate next came up.
http://www.azillionmonkeys.com/qed/goto.html

I use it all the time in C to roughly emulate structured exception handling and you will see it fairly often around the place in this use.

---

Why not just use setjmp/longjmp? This seems like it has all the advantages of the goto, plus the fact the target is not fixed at compile-time, but can be adjusted by the program as it needs.

I tend to disagree with that author, as well, as I have yet to see a real-world set of code that looks better when written with gotos vs. other forms of flow control. I don't disagree with the sentiment that you should use the best written code at all times, I just don't think gotos improve readability.

Quote:

---

Why not just use setjmp/longjmp? This seems like it has all the advantages of the goto, plus the fact the target is not fixed at compile-time, but can be adjusted by the program as it needs.

---

To me, it seems not much of an advantage not knowing the jump location at compile time. Intel processors don't predict indirect jumps, do they? (don't remember well...)
I don't really see in what cases it is interesting to have the target modified.

One example is when you call longjmp in a library and you require the caller to have called setjmp previously. This is used in place of exceptions in a lot of C libraries, like libpng for one.

It also means you could programmatically choose where your code goes on error, so you can make decisions at runtime about where you will handle errors; this may make it very easy to enable/disable a debug mode in your program.

didn't know i would spark such a huge response...

altho i really don't see how it helps readability (doesn't for me anyway) i can see how using it to skip a huge section of if statements (for example) could really speed up the program, and this is something i desperately need in my opengl apps

why not do this instead? is it really that useful to use goto in this situation?

Code:

---

if(!condition)
{
  if(something)
      //do something
  if(something)
      //do something
  if(something)
      //do something
  if(something)
      //do something
  if(something)
      //do something
  if(something)
      //do something
  if(something)
      //do something
}

---

goto does not speed up anything as far as I know if if-statements are used correctly, except some special cases maybe.

Quote:

---

...Although we could've done without goto, doing so would've been much more difficult...

---

Which is why I never use it. Most of the time I see it being used 'lazily' to solve a problem that can be done with better code.

Goto is nasty. Those of you who know asm somewhat will already realize that there are about a trillion short jumps and maybe even hundreds of long jumps in your code already. But the whole issue comes down to the fact that C provides other more polished mechanism by which to accomplish what goto does. Goto is hard to trace, hard to debug, ugly, and violates one entry one exit. Jumping to a label in C is assinine and for those of you who blast me for assembly - you are basically adding jumps to the assembly that need not be there.

Try to put the following in asm:

Code:

---

switch (x)
{
  case 1:  DoOne();break;
  case 2:  DoTwo();break;
  case 3:  goto Assinine
}

goto SkipAssinine:

Assinine:
  DoSomethingElse();

SkipAssinine:
  ContinueWithProgram();

---

See how the goto requires you to almost use assembly language fall-through in C? Very ugly. One use of goto often requires yet another uglier use of the same.

Code:

---

  mov  eax,[x]
  cmp  eax,1
  jne    Compare2
  call    DoOne
  jmp  EndOfCompare                ;only here if break is used
Compare2:
  cmp  eax,2
  jne    Compare3
  call    DoTwo
  jmp  EndOfCompare                ;only if break is used
Compare3:
  cmp  eax,3
  jne    EndofCompare
  jmp  Assinine       

Assinine:
  call DoSomethingElse
  ;Fall through to EndOfCompare

EndOfCompare:
  call ContinueWithProgram

---