goto Statement in C++ (With Examples)

The goto statement is a control flow statement in C++ that allows unconditional jumps to a labeled part of a program in the same function. Although the goto statement is a part of the C++ programming language, it is still generally advised not to use it in modern C++ programming. In this article, we will discuss what a goto statement is, its syntax, properties, examples, disadvantages, when to use goto in C++, reasons to avoid it, and preferred alternatives to the C++ goto statement.

Table of Contents:

• What is a goto statement in C++?
• Syntax of a goto statement in C++
• Flowchart of a goto Statement in C++
• Key Characteristics of the goto Statement in C++
• Practical Examples of goto Statement in C++
• When to Use goto Statement in C++
• What Happens When You Misuse goto in C++?
• Why You Should Avoid Using goto in Modern C++
• Best Alternatives to goto Statement in C++
• Code Readability vs Performance: Why goto Fails
• goto vs break vs return – Which to Use and When?
• Conclusion

What is a goto statement in C++?

A goto statement in C++ is a control flow statement that helps programs to jump or switch to another part of the same function. It provides an unconditional jump within the same function. Also, when a goto statement is executed then the control transfers directly to the specified label with skipping code in between. Structured alternatives such as loops, conditional statements, and exception handling are preferred instead of using a C++ goto statement.

Syntax of a goto statement in C++

Below is a general syntax of a goto statement in C++:

goto label;
// ... some code ...
label:
// code to execute after jump

Here, the label is a user-defined identifier with a colon(:), which shows the target location in the code.

Example:

Output:

The code shows how the goto skip; statement helps the program to jump directly to the skip: label by skipping the line “This will not be printed”, and then the execution resumes from the label and prints “After goto”.

Flowchart of a goto Statement in C++

The given flowchart shows how goto is a control flow statement in C++ that allows the program to jump unconditionally to a labeled statement, bypassing the normal sequential execution of code. It shows how the flow of execution can move directly from one point to another using a goto label, often skipping blocks of code, which can make the program harder to read and maintain if not used carefully.

Key Characteristics of the goto Statement in C++

• It transfers control to a labeled statement without any condition.
• Both the goto and the target label must be in the same function.
• A label is an identifier with a colon(:).
• The code between the goto and its label is skipped during execution.

Practical Examples of goto Statement in C++

Below are a few examples of goto statement in C++:

Example 1: Input Validation Using goto

Output:

The code shows how a C++ goto statement is used to repeatedly to give the messages to the user until a valid age input between 0 and 120 is entered, and then the result is printed to the console.

Example 2: Infinite Loop Using goto

Output:

The code shows how an infinite loop is created using the C++ goto statement, which repeatedly jumps back to the loop_start label, and then prints the message “Welcome to Intellipaat” infinite times.

Example 3: Breaking Out of Nested Loops

Output:

The code shows how a C++ goto is used to exit from both nested loops when i == 2 && j == 2, and then resumes execution at the exit_loops label to print a message and output.

Example 4: Conditional Branching using goto

Output:

The code shows how a C++ goto statement is used to jump to either to even or odd label based on the given input by the user, and then prints the result to the console.

Example 5: Simple Menu Using goto

Output:

The code shows how the C++ goto statement is used to display a menu and to handle the user input until the user chooses the exit option, and then print the result to the console.

When to Use goto Statement in C++

Below are a few conditions for when to use goto in C++:

• Breaking out of deeply nested loops, after encountering a situation that requires jumping out of multiple nested loops or conditionals at once, in this situation, a C++ goto statement can make the process easier.
• Error handling in low-level C++ code.
• When there is a need to jump to clean a section of the code before returning the value.

What Happens When You Misuse goto in C++?

Here are a few points about what happens when you misuse the goto statement in C++: 

• Destructors Can Be Skipped: If you use goto to jump over the scope of an object, its destructor won’t be called, causing potential memory leaks.
• Resource Leaks: Since destructors handle cleanup (like closing files or freeing memory), skipping them may lead to unfreed resources.
• Unpredictable Behavior: Misusing goto can result in bugs that are hard to find and reproduce, especially in larger programs.
• Hard to Read: goto breaks the normal top-to-bottom flow of code, making it harder to follow what the program is doing.
• Difficult to Maintain: When goto is used, modifying or extending the code later becomes tricky and error-prone.
• Leads to Unorganized Code: Using goto too much can make the code unorganized and confusing.

Why You Should Avoid Using goto in Modern C++

Here we are going to discuss a few disadvantages of using the goto statement in C++:

• A goto statement makes the code more difficult to understand.
• It does not follow the modern programming principles, which provide clear, modular, and flow control practices.
• It skips the constructor and destructor, which leads to memory leaks and resource management problems.
• It should be avoided because better alternatives, such as loops, conditionals, exceptions, and functions, make code reusable, safer, and readable.

Best Alternatives to goto Statement in C++

Here are the best alternatives to the C++ goto statement:

Code Readability vs Performance: Why goto Fails

In the trade-off between code readability and performance, the C++ goto statement generally fails for several key reasons:

• Readability Decreases: goto in C++makes the code flow jump around, which confuses readers and disrupts logical structure. It is harder to understand than a well-structured loop or a conditional statement.
• Maintenance Becomes Hard: When the code is messy or hard to read, it’s easier to make mistakes when changing or fixing it. The goto statement in C++ jumps around in the code, which can confuse the programmer and cause hidden bugs.
• Performance Gain Is Marginal: In nearly all practical cases, structured constructs (for, while, if) are just as fast as goto in C++ because modern compilers optimize them well.
• Modern Constructs Replace It: C++ provides structured alternatives like break, continue, return, and exceptions, which make control flow safer and clearer.
• Bugs from Skipped Cleanup: If goto in C++ jumps past destructors or cleanup logic, it can cause memory/resource leaks, something structured code avoids by design.
• Best Practice Avoids It: Modern C++ discourages goto because clean, maintainable code matters more than any little performance benefit it might provide.

goto vs break vs return – Which to Use and When?

Here is the table of return vs break vs goto in C++ that shows which to use and when:

Conclusion

The C++ goto statement helps in switching to a labeled part of code in the same function. It has some practical applications, but it is mainly advised not to use the goto statement for a few reasons. Also, there are various disadvantages of the goto statement, due to which it is better to use other alternatives such as loops and conditional statements. So, by understanding what a goto statement is, return vs break vs goto in C++, when to use it, and when to avoid it, you can easily write a C++ program using the goto statement.

C++ goto Statement – FAQs