53470d2fd8
Removed some statements talking about the optimization potential of goto (which is mentioned but never specified), and I gave a possible use-case for goto followed by some constructs that can replace it, and ended on why goto is discouraged in C++ Added information about the memory behaviour of labels, the syntax to create a label, and where a label can actually be placed (within the same function).
91 lines
3.1 KiB
Markdown
91 lines
3.1 KiB
Markdown
---
|
|
title: goto
|
|
---
|
|
|
|
# Intro to the use of goto and labels
|
|
|
|
`goto label` goes to the mentioned occurence of the `label`, which can be either before or after the `goto` statement, as long as the `label` is in the same function as the `goto` statement.
|
|
|
|
If a `goto` causes program execution to exit some scope where a variable is defined, then the variable will be destroyed. If multiple of these variables exist, then they will be destroyed in opposite order of their construction.
|
|
|
|
See https://en.cppreference.com/w/cpp/language/goto for more information.
|
|
|
|
A common use of `goto` is to break out of a multiply-nested loop following some condition. However, there are several C++ language constructs that can be used to avoid this use case, including early `returns`, refactoring into different functions, and local variables in the loop.
|
|
|
|
**The use of goto is discouraged in C++, since it encourages poor design and creates code that is hard to debug and trace through. https://stackoverflow.com/questions/3517726/what-is-wrong-with-using-goto#3517746)**
|
|
|
|
|
|
# Terminology
|
|
|
|
goto - The keyword used to go to the particular label.
|
|
label - this can be named anything.
|
|
|
|
# Syntax
|
|
|
|
```cpp
|
|
goto labelName; //This takes the program flow to the next appearance of label.
|
|
labelName: //to create a label name, write the name followed by a colon
|
|
```
|
|
|
|
# Scope
|
|
|
|
`goto` can only jump to a label in the **same scope** (set of braces - {}).
|
|
|
|
### Example:
|
|
```cpp
|
|
#include <iostream>
|
|
int main(){
|
|
goto x:
|
|
std::cout << "Hello World"; //no text is printed.
|
|
x:
|
|
return 0;
|
|
}
|
|
int someFunction(){
|
|
x: //the program does not jump to this label becaue it is in another scope.
|
|
return 0;
|
|
}
|
|
```
|
|
|
|
`goto` is something that transcends all loops. To be clearer on this point, here is an example.
|
|
|
|
```cpp
|
|
#include <iostream>
|
|
using std::cout;
|
|
|
|
int main(){
|
|
for(;;){
|
|
if(1) goto label;
|
|
}
|
|
|
|
label:
|
|
cout << "lol";
|
|
//here, goto is used to get out of an otherwise infinite loop. That is one of the only places where goto is tolerated.
|
|
|
|
return 0;
|
|
}
|
|
```
|
|
|
|
Even though the above code works, a **much** better option is to structure your code such that `goto` is not needed for the program flow. For this reason, many modern programming languages (like java, javascript, python, etc.) do support `goto`. Instead, control statements like `break` and `continue` are used.
|
|
|
|
The above example can be rewritten using `break` as:
|
|
|
|
```cpp
|
|
#include <iostream>
|
|
using std::cout;
|
|
|
|
int main(){
|
|
for(;;){
|
|
if(1) break;
|
|
}
|
|
|
|
cout << "lol";
|
|
|
|
return 0;
|
|
}
|
|
```
|
|
|
|
**However, care must be taken to use goto very carefully**, especially in the early days of coding as it can lead to crazy issues, if not understood well enough. `goto` violates the standard flow of the program, and as C++ is an object oriented language, goto should **NEVER EVER, EVER** be used in a normal program, under **ANY CIRCUMSTANCES**. The same effect can usually be replicated by using functions or loops, with the resulting code being easier to read as well as maintain.
|
|
|
|
#### The consequences of using goto are illustrated in this XKCD comic (#292)
|
|
|