When I learned C, teacher told me all day long: &quot;Don&#39;t use goto, that&#39;s a bad habit, it&#39;s ugly, it&#39;s dangerous!&quot; and so on.

Why then, do some kernel programmers use `goto`, for example [in this function][1], where it could be replaced with a simple 

    while(condition) {} 

or 

    do {} while(condition);

I can&#39;t understand that. Is it better in some cases to use goto instead of `while`/`do`-`while`? And if so, why?


  [1]: https://github.com/torvalds/linux/blob/391e43da797a96aeb65410281891f6d0b0e9611c/kernel/sched/clock.c#L141

Why do some kernel programmers use goto instead of simple while loops?

I&#39;ve seen a suggested coding standard that reads `Never use goto unless in a switch statement fall-through`.

I don&#39;t follow.  What exactly would this &#39;exception&#39; case look like, that justifies a `goto`?

Use a &#39;goto&#39; in a switch?

I figure most of you know that `goto` is a reserved keyword in the Java language but is not actually used. And you probably also know that `goto` is a Java Virtual Machine (JVM) opcode. I reckon all the sophisticated control flow structures of Java, Scala and Kotlin are, at the JVM level, implemented using some combination of `goto` and `ifeq`, `ifle`, `iflt`, etc.

Looking at the JVM spec https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.goto_w I see there&#39;s also a `goto_w` opcode. Whereas `goto` takes a 2-byte branch offset, `goto_w` takes a 4-byte branch offset. The spec states that 

&gt; Although the *goto_w* instruction takes a 4-byte branch offset, other factors limit the size of a method to 65535 bytes (&#167;4.11). This limit may be raised in a future release of the Java Virtual Machine.

It sounds to me like `goto_w` is future-proofing, like some of the other `*_w` opcodes. But it also occurs to me that maybe `goto_w` could be used with the two more significant bytes zeroed out and the two less significant bytes the same as for `goto`, with adjustments as needed.

For example, given this Java Switch-Case (or Scala Match-Case):

```
     12: lookupswitch  {
                112785: 48 // case &quot;red&quot;
               3027034: 76 // case &quot;green&quot;
              98619139: 62 // case &quot;blue&quot;
               default: 87
          }
      48: aload_2
      49: ldc           #17                 // String red
      51: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      54: ifeq          87
      57: iconst_0
      58: istore_3
      59: goto          87
      62: aload_2
      63: ldc           #19                 // String green
      65: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      68: ifeq          87
      71: iconst_1
      72: istore_3
      73: goto          87
      76: aload_2
      77: ldc           #20                 // String blue
      79: invokevirtual #18 
      // etc.
```

we could rewrite it as 

```
     12: lookupswitch  { 
                112785: 48
               3027034: 78
              98619139: 64
               default: 91
          }
      48: aload_2
      49: ldc           #17                 // String red
      51: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      54: ifeq          91 // 00 5B
      57: iconst_0
      58: istore_3
      59: goto_w        91 // 00 00 00 5B
      64: aload_2
      65: ldc           #19                 // String green
      67: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      70: ifeq          91
      73: iconst_1
      74: istore_3
      75: goto_w          91
      79: aload_2
      81: ldc           #20                 // String blue
      83: invokevirtual #18 
      // etc.
```

I haven&#39;t actually tried this, since I&#39;ve probably made a mistake changing the &quot;line numbers&quot; to accommodate the `goto_w`s. But since it&#39;s in the spec, it should be possible to do it.

My question is whether there is a reason a compiler or other generator of bytecode might use `goto_w` with the current 65535 limit other than to show that it can be done?

Do any compilers for the JVM use the &quot;wide&quot; goto?

Consider the following code:

    void foo()
    {
        {
            CSomeClass bar;
     
            // Some code here...
    
            goto label;
            
            // and here...
        }
    
    label:
        // and here...
    }
    
Will the destructor of bar be called ?

Goto out of a block: do destructors get called?

Everyone is aware of Dijkstra&#39;s [Letters to the editor: go to statement considered harmful][1] (also [here][2] .html transcript and [here][3] .pdf) and there has been a formidable push since that time to eschew the goto statement whenever possible. While it&#39;s possible to use goto to produce unmaintainable, sprawling code, it nevertheless remains in [modern programming languages][4]. Even the advanced [continuation][5] control structure in Scheme can be described as a sophisticated goto.

What circumstances warrant the use of goto? When is it best to avoid?

As a follow-up question: C provides a pair of functions, setjmp() and longjmp(), that provide the ability to goto not just within the current stack frame but within any of the calling frames. Should these be considered as dangerous as goto? More dangerous?

----------
Dijkstra himself regretted that title, for which he was not responsible. At the end of [EWD1308][6] (also [here][7] .pdf) he wrote:

&gt; Finally a short story for the record.
&gt; In 1968, the Communications of the ACM
&gt; published a text of mine under the
&gt; title &quot;*The goto statement considered
&gt; harmful*&quot;, which in later years would
&gt; be most frequently referenced,
&gt; regrettably, however, often by authors
&gt; who had seen no more of it than its
&gt; title, which became a cornerstone of
&gt; my fame by becoming a template: we
&gt; would see all sorts of articles under
&gt; the title &quot;X considered harmful&quot; for
&gt; almost any X, including one titled
&gt; &quot;Dijkstra considered harmful&quot;. But
&gt; what had happened? I had submitted a
&gt; paper under the title &quot;***A case against
&gt; the goto statement***&quot;, which, in order
&gt; to speed up its publication, the
&gt; editor had changed into a &quot;letter to
&gt; the Editor&quot;, and in the process he had
&gt; given it a new title of his own
&gt; invention! The editor was Niklaus
&gt; Wirth.

A well thought out classic paper about this topic, to be matched to that of Dijkstra, is [Structured Programming with go to Statements][8], by Donald E. Knuth. Reading both helps to reestablish context and a non-dogmatic understanding of the subject. In this paper, Dijkstra&#39;s opinion on this case is reported and is even more strong:

&gt; *Donald E. Knuth:* I believe that by presenting such a
&gt; view I am not in fact disagreeing
&gt; sharply with Dijkstra&#39;s ideas, since
&gt; he recently wrote the following:
&gt; &quot;Please don&#39;t fall into the trap of
&gt; believing that I am terribly
&gt; dogmatical about [the go to
&gt; statement]. **I have the uncomfortable
&gt; feeling that others are making a
&gt; religion out of it, as if the
&gt; conceptual problems of programming
&gt; could be solved by a single trick, by
&gt; a simple form of coding discipline!**&quot;


  [1]: http://portal.acm.org/citation.cfm?doid=362947
  [2]: http://www.cs.utexas.edu/~EWD/transcriptions/EWD02xx/EWD215.html
  [3]: http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF
  [4]: http://msdn.microsoft.com/en-us/library/13940fs2(VS.71).aspx
  [5]: http://en.wikipedia.org/wiki/Goto#Continuations
  [6]: http://www.cs.utexas.edu/~EWD/transcriptions/EWD13xx/EWD1308.html
  [7]: http://www.cs.utexas.edu/%7EEWD/ewd13xx/EWD1308.PDF
  [8]: http://www.clifford.at/cfun/cliffdev/p261-knuth.pdf
  [9]: https://paperhub.s3.amazonaws.com/baab8568793b2d1032d79f34a18b5bc5.pdf

GOTO still considered harmful?

I am self teaching myself python 2.7. I  have some experience in using BATCH, which has a GOTO statement.  How do I do that in python? For example, suppose I want to jump from line 5 to line 18.

I realize there have been previous questions regarding this topic, but I have not found them sufficiently informative or, are too high level in python for my current understanding.



The equivalent of a GOTO in python

I saw a program in C that had code like the following:

    static void *arr[1]  = {&amp;&amp; varOne,&amp;&amp; varTwo,&amp;&amp; varThree};

    varOne: printf(&quot;One&quot;) ;
    varTwo: printf(&quot;Two&quot;) ;
    varThree: printf(&quot;Three&quot;) ;


I am confused about what the `&amp;&amp;` does because there is nothing to the left of it. Does it evaluate as null by default? Or is this a special case?

Edit: 
Added some more information to make the question/code more clear for my question.
Thank you all for the help. This was a case of the gcc specific extension.

What does a &amp;&amp; operator do when there is no left side in C?

I&#39;m confused about this. Most of us have been told that there isn&#39;t any goto statement in Java.

But I found that it is one of the keywords in Java. Where can it be used? If it can not be used, then why was it included in Java as a keyword?

Is there a goto statement in Java?

Is there a &quot;goto&quot; statement in bash ? I know It is considered bad practice, but I need specifically &quot;goto&quot;.

Is there a &quot;goto&quot; statement in bash?

Is there a `goto` or any equivalent in Python to be able to jump to a specific line of code?

Is there a label/goto in Python?

I&#39;ve long been under the impression that `goto` should never be used if possible.

However, while perusing libavcodec (which is written in C) the other day, I was surprised to notice multiple uses of it.

Is it ever advantageous to use `goto` in a language that supports loops and functions?  If so, why?   Please provide a concrete example that clearly justifies the use of a `goto`.


Are there any legitimate use-cases for &quot;goto&quot; in a language that supports loops and functions?

&gt; **Possible Duplicates:**  
&gt; [Why is it bad to use goto?](https://stackoverflow.com/questions/3444060/why-is-it-bad-to-use-goto)  
&gt; [GOTO still considered harmful?](https://stackoverflow.com/questions/46586/goto-still-considered-harmful)  

&lt;!-- End of automatically inserted text --&gt;

I was ramdomming through xkcd and saw this one (if also read some negative texts about them some years ago):  
![your slow connection sucks, get a faster one to see this image](https://imgs.xkcd.com/comics/goto.png)  
What is actually wrong with it? Why are goto&#39;s even possible in C++ then?

Why should I **not** use them?

What is wrong with using goto?

I have some code that I absolutely must implement using `goto`. For example, I want to write a program like this:

    start:
    alert(&quot;RINSE&quot;);
    alert(&quot;LATHER&quot;);
    repeat: goto start

Is there a way to do that in Javascript?

How can I use goto in Javascript?

I was surprised to find that Go has a [&#39;goto&#39;][1] statement. I&#39;ve always been taught that &#39;goto&#39; statements are a thing of the past and evil for it occludes the actual flow of a program, and that functions or methods are always a better way of controlling flow.

I must be missing something. Why did Google include it?

  [1]: http://golang.org/ref/spec#Goto_statements






Why does Go have a &quot;goto&quot; statement?

I was wondering whether anyone still uses the &quot;goto&quot; keyword syntax in C# and what possible reasons there are for doing so. 

I tend to view any statements that cause the reader to jump around the code as bad practice but wondered whether there were any credible scenarios for using such a syntax?

[Goto Keyword Definition][1]


  [1]: http://msdn.microsoft.com/en-us/library/13940fs2%28v=vs.71%29.aspx

Does anyone still use [goto] in C# and if so why?

This question is actually a result of an [interesting discussion][1] at programming.reddit.com a while ago. It basically boils down to the following code:

    int foo(int bar)
    {
    	int return_value = 0;
        if (!do_something( bar )) {
            goto error_1;
        }
        if (!init_stuff( bar )) {
            goto error_2;
        }
        if (!prepare_stuff( bar )) {
            goto error_3;
        }
        return_value = do_the_thing( bar );
    error_3:
    	cleanup_3();
    error_2:
    	cleanup_2();
    error_1:
    	cleanup_1();
        return return_value;
    }

The usage of `goto` here appears to be the best way to go, resulting in the cleanest and most efficient code of all possibilities, or at least so it seems to me. Quoting Steve McConnell in *Code Complete*:

&gt; The goto is useful in a routine that
&gt; allocates resources, performs
&gt; operations on those resources, and
&gt; then deallocates the resources. With a
&gt; goto, you can clean up in one section
&gt; of the code. The goto reduces the
&gt; likelihood of your forgetting to
&gt; deallocate the resources in each place
&gt; you detect an error.

Another support for this approach comes from the *Linux Device Drivers* book, in [this section][2].

What do you think? Is this case a valid use for `goto` in C? Would you prefer other methods, which produce more convoluted and/or less efficient code, but avoid `goto`?


  [1]: http://www.reddit.com/r/programming/comments/8cx8m/error_handling_in_c_you_are_going_to_fail_in_a/
  [2]: http://www.xml.com/ldd/chapter/book/ch02.html#buierr

Valid use of goto for error management in C?

Is it true that `goto` jumps across bits of code without calling destructors and things?

e.g.

    void f() {
       int x = 0;
       goto lol;
    }
    
    int main() {
       f();
    lol:
       return 0;
    }

Won&#39;t `x` be leaked?

Will using goto leak variables?

What is an alternative function for the **goto** keyword in Java?

Since Java does not have a goto.


Alternative to a goto statement in Java

In this thread, we look at examples of good uses of `goto` in C or C++.  It&#39;s inspired by [an answer][1] which people voted up because they thought I was joking.

Summary (label changed from original to make intent even clearer):


    infinite_loop:

        // code goes here

    goto infinite_loop;


Why it&#39;s better than the alternatives:

  - It&#39;s specific.  `goto` is the
    language construct which causes an
    unconditional branch.  Alternatives
    depend on using structures
    supporting conditional branches,
    with a degenerate always-true
    condition.
  - The label documents the intent
    without extra comments.
  - The reader doesn&#39;t have to scan the
    intervening code for early `break`s
    (although it&#39;s still possible for an
    unprincipled hacker to simulate
    `continue` with an early `goto`).

**Rules:**

  - Pretend that the gotophobes didn&#39;t
    win.  It&#39;s understood that the above
    can&#39;t be used in real code because
    it goes against established idiom.
  - Assume that we have all heard of
    &#39;Goto considered harmful&#39; and know
    that goto can be used to write
    spaghetti code.
  - If you disagree with an example,
    criticize it on technical merit
    alone (&#39;Because people don&#39;t like
    goto&#39; is not a technical reason).

Let&#39;s see if we can talk about this like grown ups.



  [1]: https://stackoverflow.com/questions/244445/best-refactoring-for-the-dreaded-while-true-loop#244644




**Edit**

This question seems finished now.  It generated some high quality answers.  Thanks to everyone,
 especially those who took my little loop example seriously.  Most skeptics were concerned
 by the lack of block scope.  As @quinmars pointed out in a comment, you can always put braces around the 
loop body.  I note in passing that `for(;;)` and `while(true)` don&#39;t give you the braces 
for free either (and omitting them can cause vexing bugs).  Anyway, I won&#39;t waste any more
of your brain power on this trifle - I can live with the harmless and idiomatic `for(;;)` and `while(true)` (just as well if I want to keep my job).  

Considering the other responses, I see that many people view `goto` as something you always 
have to rewrite in another way.  Of course you can avoid a `goto` by introducing a loop,
 an extra flag, a stack of nested `if`s, or whatever, but why not consider whether `goto` is 
perhaps the best tool for the job? Put another way, how much ugliness are people prepared to endure to avoid using a built-in language feature for its intended purpose? My take is that
even adding a flag is too high a price to pay.  I like my variables to represent things in 
the problem or solution domains. &#39;Solely to avoid a `goto`&#39; doesn&#39;t cut it.


I&#39;ll accept the first answer which gave the C pattern for branching to a cleanup block. IMO, this makes the strongest case for a `goto` of all the posted answers, certainly 
if you measure it by the contortions a hater has to go through to avoid it.

Examples of good gotos in C or C++

Today I found one interesting thing. I didn&#39;t know that one can&#39;t declare a variable after a goto label. 

Compiling the following code

    #include &lt;stdio.h&gt;
    int main() {
        int x = 5;
        goto JUMP;
        printf(&quot;x is : %d\n&quot;,x);
    JUMP:
        int a = 0;  &lt;=== giving me all sorts of error..
        printf(&quot;%d&quot;,a);
    }

gives errors like

    temp.c: In function ‘main’:
    temp.c:7: error: expected expression before ‘int’
    temp.c:8: error: ‘a’ undeclared (first use in this function)
    temp.c:8: error: (Each undeclared identifier is reported only once
    temp.c:8: error: for each function it appears in.)

Now what is the logic behind that? I heard that **one cannot create variables inside the case statements of switch**. Since JUMP is inside the same scope (the scope of main function, in my case) of the goto statement, I believe that scope is not an issue here. But then, why am I getting this error?

 


Variable declaration after goto Label

I recently found out that PHP 5.3 supports new language construct called `GOTO`. Everybody knows what it does. However, it&#39;s not exactly the traditional `GOTO`, it&#39;s just a jump label. I&#39;m interesting in knowing whether this `GOTO` is evil and implies bad code?

Is GOTO in PHP evil?

What if I have nested loops, and I want to break out of all of them at once?

    while (true) {
        // ...
        while (shouldCont) {
            // ...
            while (shouldGo) {
                // ...
                if (timeToStop) {
                    break; // Break out of everything?
                }
            }
        }
    }

In PHP, `break` takes an argument for the number of loops to break out of. Can something like this be done in C#?

What about something hideous, like `goto`?

    // In the innermost loop
    goto BREAK
    // ...
    BREAK: break; break; break;


How to break out of multiple loops at once in C#?

Currently I am working on a project where goto statements are heavely used. The main purpose of goto statements is to have one cleanup section in a routine rather than multiple return statements.
Like below:

    BOOL foo()
    {
       BOOL bRetVal = FALSE;
       int *p = NULL;

       p = new int;
       if (p == NULL)
       {
         cout&lt;&lt;&quot; OOM \n&quot;;
         goto Exit;
       }

       // Lot of code...

    Exit:
       if(p)
       {
         delete p;
         p = NULL;
       }
       return bRetVal;
    }

This makes it much easier as we can track our clean up code at one section in code, that is, after the Exit label.

However, I have read many places it&#39;s bad practice to have goto statements.

Currently I am reading the *[Code Complete][1]* book, and it says that we need to use variables close to their declarations. If we use goto then we need to declare/initialize all variables before first use of goto otherwise the compiler will give errors that initialization of xx variable is skipped by the goto statement.

Which way is right?

---

From Scott&#39;s comment:

It looks like using goto to jump from one section to another is bad as it makes the code hard to read and understand.

But if we use goto just to go forward and to one label then it should be fine(?).

  [1]: https://en.wikipedia.org/wiki/Code_Complete


To GOTO or not to GOTO?

We have a situation at work where developers working on a legacy (core) system are being pressured into using GOTO statements when adding new features into existing code that is already infected with spaghetti code.

Now, I understand there may be arguments for using &#39;just one little GOTO&#39; instead of spending the time on refactoring to a more maintainable solution. The issue is, this isolated &#39;just one little GOTO&#39; isn&#39;t so isolated. At least once every week or so there is a new &#39;one little GOTO&#39; to add. This codebase is already a horror to work with due to code dating back to or before 1984 being riddled with GOTOs that would make many [Pastafarians][1] believe it was inspired by the Flying Spaghetti Monster itself.

Unfortunately the language this is written in doesn&#39;t have any ready made refactoring tools, so it makes it harder to push the &#39;Refactor to increase productivity later&#39; because short-term wins are the only wins paid attention to here...

Has anyone else experienced this issue whereby everybody agrees that we cannot be adding new GOTOs to jump 2000 lines to a random section, but continually have Anaylsts insist on doing it just this one time and having management approve it?

**tldr;**

How can one go about addressing the issue of developers being pressured (forced) to continually add GOTO statements (by add, I mean add to jump to random sections many lines away) because it &#39;gets *that* feature in quicker&#39;?

I&#39;m beginning to fear we may lose valuable developers to the raptors over this...

![Credit: XKCD][2]


**Clarification:**

*Goto* `here`


`alsoThere:` No, I&#39;m talking about the kind of goto that jumps 1000 lines out of one subroutine into another one mid way into a while loop. *Goto* `somewhereClose`

`there:` I wasn&#39;t even talking about the kind of gotos you can reasonably read over and determine what a program was doing. *Goto* `alsoThere`


`somewhereClose:` This is the sort of code that makes meatballs `midpoint:` *If first time here Goto* `nextpoint` `detail:`(each one almost completely different) *Goto* `pointlessReturn`

`here:` In this question, I was not talking about the occasionally okay use of a goto. Goto `there`

`tacoBell:` and it has just gone back to the drawing board. *Goto* `Jail`

`elsewhere:` When it takes Analysts weeks to decypher what a program is doing each time it is touched, something is deeply wrong with your codebase. In fact, I&#39;m actually up to my `hell:`*if not up-to-date goto* `4` rendition of the spec *goto* `detail` `pointlessReturn:` *goto* `tacoBell`

`Jail:` Actually, just a small update with a small victory. I spent 4 hours refactoring a portion of this particular program a single label at a time, saving each iteration in svn as I went. Each step (about 20 of them) was smallish, logical and easy enough to *goto* `bypass` `nextpoint:` spontaneously jump out of your meal and onto you screen through some weird sort of spaghetti-meatball magnetism. *Goto* `elseWhere`
 `bypass:` reasonably verify that it should not introduce any logic changes. Using this new more readable version, I&#39;ve sat down with the analyst and completed almost all of this change now. *Goto* `end`

`4:` first *if first time here goto `hell`, no second *if first time here goto* `hell`, no third *if first time here goto* `hell` fourth *now up-to-date goto* `hell`

`end:`

  [1]: http://en.wikipedia.org/wiki/Pastafarian
  [2]: https://imgs.xkcd.com/comics/goto.png

Being pressured to GOTO the dark-side

I know everyone hates gotos. In my code, for reasons I have considered and am comfortable with, they provide an effective solution (ie I&#39;m not looking for &quot;don&#39;t do that&quot; as an answer, I understand your reservations, and understand why I am using them anyway). 

So far they have been fantastic, but I want to expand the functionality in such a way that requires me to essentially be able to store pointers to the labels, then go to them later. 

If this code worked, it would represent the type of functionality that I need. But it doesn&#39;t work, and 30 min of googling hasn&#39;t revealed anything. Does anyone have any ideas?


    int main (void)
    {
      int i=1;
      void* the_label_pointer;
    
      the_label:
    
      the_label_pointer = &amp;the_label;
    
      if( i-- )
        goto *the_label_pointer;
    
      return 0;
    }



Is it possible to store the address of a label in a variable and use goto to jump to it?

After doing some reseach on how to break through a secondary loop

    while (true) { // Main Loop
       for (int I = 0; I &lt; 15; I++) { // Secondary loop
           // Do Something
           break; // Break main loop?
       }
    }

most people recommended to call the &#39;goto&#39; function
&lt;br&gt;Looking as the following example:

    while (true) { // Main Loop
       for (int I = 0; I &lt; 15; I++) { // Secondary Loop
           // Do Something
           goto ContinueOn; // Breaks the main loop
       }
    }
    ContinueOn:

However; I have often heard that the &#39;goto&#39; statement is bad practice. The picture below is perfectly illustrating my point: 
[![Series found][1]](https://xkcd.com/292/)

## So ##
* &lt;b&gt;How bad is the goto statement really, and why?&lt;/B&gt;
* &lt;b&gt;Is there a more effective way to break the main loop than using the &#39;goto&#39; statement?&lt;/b&gt;

  [1]: http://i.stack.imgur.com/thuIW.png

All Goto Solutions on Gang of Coders

Total of 26 Goto Solutions