When I say "goto", my parrot says "Spaghetti Code"

[den2k88]

That's a nice spot to use goto, I have used it twice in my life precisely for that: later I ended up removing them due to a refactor that improved every aspect of those functions (performance, readability, debuggability). That said, I don't discard it out of hand as it is a powerful tool. As TNCaver said "You think goto is evil: try writing Assembly programs without JMP" (it has been in my signature for years... and I do also write Assembly code so it was really appropriate).

GCS d-- s-/++ a- C++++ U+++ P- L+@ E-- W++ N+ o+ K- w+++ O? M-- V? PS+ PE- Y+ PGP t+ 5? X R+++ tv-- b+(+++) DI+++ D++ G e++ h--- ++>+++ y+++*      Weapons extension: ma- k++ F+2 X

[KBZX5000]

You can use goto to short-circuit time-constrained algorithms for academic or scientific purposes. Don't use it anywhere else, especially not in a professional setting, or people will be strongly compelled to gut, rape and murder your code the first chance they get. And can you really blame them for it?

[DKWatson]

As with any instruction in any language, improper use will get you into trouble. There are some 470,000 words in Webster's dictionary. Day-to-day we typically use less than 500. The others are there just in case but that doesn't mean we have to use them. The closer to bare metal you get, the more the higher level languages simply carry too much overhead to be practical. In resource-constrained environments you don't have the luxury of being elegant. On a 32K platform you're limited to about 3-5,000 lines of (C) code, you need to be creative and shortcuts save program space. When the need arises for an assembly stub, branches and jumps (assembly level GOTOs) are a way of life. The GOTO instruction is a tool and like any tool, use it if you need it, but don't use it just because it's there. As it is said, if the only tool in your box is a hammer, you're constrained to build everything with nails, but if you need to nail something, it's useful (not necessary) to have a hammer.

[Plamen Dragiyski]

den2k88 wrote:

breaks modularity in C code

That is true for C, but not so much for C++. goto is context dependent in C++, it will call appropriate constructors/destructors. When used in local context it will not make the function/method monolithic. So if goto is so bad, you might be using a badly outdated language?

[den2k88]

Plamen Dragiyski wrote:

goto is context dependent in C++, it will call appropriate constructors/destructors.

Which is an Access Violation waiting to happen when the code changes.

Plamen Dragiyski wrote:

So if goto is so bad, you might be using a badly outdated language?

And that would be?

GCS d-- s-/++ a- C++++ U+++ P- L+@ E-- W++ N+ o+ K- w+++ O? M-- V? PS+ PE- Y+ PGP t+ 5? X R+++ tv-- b+(+++) DI+++ D++ G e++ h--- ++>+++ y+++*      Weapons extension: ma- k++ F+2 X

[soulesurfer]

This question has received lots of humorous responses, now for a slightly more serious one ;) Yes, we used to use gotos a lot in the old days (and I'm actually old enough to say that :)). But my feeling now is that any language where I ever feel the need to use a goto is a flawed language. But seriously, the original "Go To Considered Harmful" [https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf\] was a brilliant step in providing discipline to coding to narrow the gap between algorithm design and implementation. A main idea being that gotos break the provability of correctness. Anybody can tell you that extensive use of gotos was involved in large numbers of defects (thus quite costly). One other point I'd like to make is that gotos can interfere with optimizers.

[Plamen Dragiyski]

den2k88 wrote:

Which is an Access Violation waiting to happen when the code changes.

How? If jumping outside block can causes access violation, then every "}" is potential access violation. If you talk about inter-scope goto, that's is entirely different story. You can do that in C using signals. What will be the state in C++ after such goto it is indeed unknown, so that's one possible misuse of goto. But if all affected variables are on the stack (and in C++ they should be - all pointer should be wrapped into appropriate *_ptr object allocated on the stack), jumping outside of scope is completely safe. Jumping inside non-conditional scopes is also safe. Jumping inside anything else is a bad idea. Jumping outside scope, can be realized by do-while wrapping:

do {
// ... you can use break here
} while(false);

But it cannot be used inside loop/switch statement and it is utterly more ugly than goto.

[englebart]

Add this info on your original post.

[englebart]

Java replaced goto with labeled break and continue. They kept goto as a reserved keyword that you cannot use. I wish C# had followed that model, but I suspect MS decided it was safer to follow C++ (which followed C) for legal reasons. (lawyers designing coding languages!) C++ made some uses of goto illegal that were allowed in C due to constructor/destructor scope constraints.

[bleahy48]

Edsger Dijkstra (March 1968). "Go To Statement Considered Harmful". Communications of the ACM (PDF). 11 (3): 147–148. doi:10.1145/362929.362947. The unbridled use of the go to statement has as an immediate consequence that it becomes terribly hard to find a meaningful set of coordinates in which to describe the process progress. ... The go to statement as it stands is just too primitive, it is too much an invitation to make a mess of one's program.

[obermd]

The problem with goto is it makes it trivially easy to write spaghetti code. It is also the one of few jump methods available to a computer, so once you get down to the hardware goto (jmp) can be found nearly everywhere. On the other hand, you can write spaghetti code in any language, even those without goto, simply by not factoring any control structures properly.

[User 13612524]

goto overuse makes it very difficult to understand and debug a program. There are legitmate uses of goto, such as breaking out of a loop, but in those cases I would just use the keywords that do the same thing for clarity. I had the joy to try and debug someone's code that was riddled with gotos. He also had the nasty habit of making functions several hundred lines long. I ended up just rewriting everything he wrote. I still feel that was the correct decision, and it only took me a couple days.

[SeattleC]

Every programmer is taught that goto leads to spaghetti code. When they are new, they struggle to do without goto, adding termination variables and writing weirdly nested loops. They pass through an intermediate stage where they occasionally give in to the urge to use goto, typically to get out of a deeply nested loop or in case of error. They then author threads like this one, seeking to justify their need for goto to the world as, "It's not so bad if used ." If they don't change careers, and if they keep on improving their skills, developers eventually reach a point where the last time they used a goto is receding in the rearview mirror of time. They write smaller, simpler functions. They don't nest loops so much because they get better at understanding termination conditions. They learn to do tricks with break and continue, which provides somewhat more structured alternatives to the goto. And they read threads like this one and sigh.

[Navanax]

Yup, been there. Just after starting my first "real" job in the early PC days (company upgraded the network file server to a bleeding-edge IBM AT just after I started), I had to debug a DOS BASIC program that implemented the equivalent of function/subroutine calls by saving the return line in a variable (all global, single letter optionally followed by a single digit), setting an ON ERROR GOTO for the desired function, then forcing an exception, and using the same mechanism with the saved return line value to return. Written by a nuclear physicist, no REMarks in the code - just the physicist's hand-scrawled notes. I might be mistaken, but I seem to recall that there was a way to set the ON ERROR GOTO for different target lines depending on the exception code generated, and this was used to pick which "function" to "call" at various locations in the code. Today, he probably would have coded the entire thing as a single Excel macro with just Row-Column cell references and of course, no labels, headings, etc. :laugh:

[Martijn Smitshoek]

I rarely use "goto", but when I do it is usually: - to "break" twice out of some construct. (goto just_past_outer_loop) - (C) to implement an error handling construct with a clean exit, that jumps to a dedicated piece of rollback code, like

result = criticalaction1();
if (!result) goto error_exit;
result = criticalaction2();
if (!result) goto rollback_action1;
return SUCCESS;

rollback_action1:
undoaction1()
error_exit:
return FAILURE;

"spaghetti code" is a lazy, pseudocritical kind of comment. I hate it with a passion. If a Pavlov response is the only thing you're capable of, you should pick another job. I'm serious.

[TNCaver]

My sig line says it all.

If you think 'goto' is evil, try writing an Assembly program without JMP.

[AnotherKen]

I used basic in the past and for that language GOTO was very convenient for establishing looping and simple procedural content. The reason many teachers discourage it's use is that it can very easily lead to the development of spaghetti code. That said, the presence of a GOTO statement should not be seen as an automatic sign of spaghetti code. GOTO can be used to produce good code that is in no way likely to be judged negatively by a true computer scientist (at least on that basis, alone).

[jschell]

RandyBuchholz wrote:

Have we developed an irrational fear of goto born out of ancient coding dogma? Or is goto inherently and absolutely evil?

Ask anyone any of the following - Which is better Windows or Linux - Which is better C#, Python, Java or C++ - Which is better Relational databases or NoSQL databases - Which is better micro-services or traditional server based solutions. - Which is better Waterfall or Agile. - Ask them if they write maintainable and readable code. And of course then follow up with asking them to specify exactly what objective measurements they took to validate their response. Or even ask them how they would objectively measure it if they had the time and money.

[jschell]

den2k88 wrote:

Which is an Access Violation waiting to happen when the code changes.

And you are claiming that cannot happen without gotos? Or if those others occur they can only occur when another feature of the language is used correctly?