8.7 — Goto statements

In this lesson, you'll learn about goto statements, understand why they're generally discouraged in modern programming, explore the rare cases where they might be appropriate, and discover better alternatives for control flow.

What is a goto statement?

A goto statement is an unconditional jump that transfers control to another part of the program marked by a label. It's one of the most controversial features in programming languages.

goto label;
// ... other code ...
label:
    // Code execution continues here

Basic goto syntax and example

#include <iostream>

int main()
{
    int x = 1;
    
    std::cout << "Start of program\n";
    
    if (x == 1)
    {
        goto skip_section;  // Jump to the label
    }
    
    std::cout << "This line will be skipped\n";
    std::cout << "This line will also be skipped\n";
    
skip_section:
    std::cout << "End of program\n";
    
    return 0;
}

Output:

Start of program
End of program

The program jumps over the middle section because x == 1 is true.

Why goto is discouraged

1. Creates "spaghetti code"

Goto statements can make code flow confusing and hard to follow:

#include <iostream>

int main()
{
    int x = 1;
    
start:
    std::cout << "At start, x = " << x << std::endl;
    
    if (x == 1)
    {
        x = 2;
        goto middle;
    }
    
    if (x == 3)
    {
        goto end;
    }
    
    goto start;
    
middle:
    std::cout << "In middle, x = " << x << std::endl;
    x = 3;
    goto start;
    
end:
    std::cout << "At end, x = " << x << std::endl;
    
    return 0;
}

Output:

At start, x = 1
In middle, x = 2
At start, x = 3
At end, x = 3

This code is difficult to understand and maintain.

2. Breaks structured programming principles

// Bad - goto breaks out of structured blocks
#include <iostream>

int main()
{
    for (int i = 0; i < 5; ++i)
    {
        if (i == 2)
        {
            goto skip_rest;  // Jumping out of nested structures
        }
        
        for (int j = 0; j < 3; ++j)
        {
            if (j == 1 && i == 3)
            {
                goto skip_rest;  // Another jump from deep nesting
            }
            std::cout << "i=" << i << ", j=" << j << std::endl;
        }
    }
    
skip_rest:
    std::cout << "Skipped to here\n";
    
    return 0;
}

3. Makes debugging difficult

#include <iostream>

int main()
{
    int state = 1;
    
    // Debugging nightmare - where did execution come from?
process:
    std::cout << "Processing state " << state << std::endl;
    
    if (state == 1)
    {
        state = 2;
        goto validate;
    }
    
    if (state == 2)
    {
        goto cleanup;
    }
    
validate:
    std::cout << "Validating state " << state << std::endl;
    if (state == 2)
    {
        goto process;  // Back to process
    }
    
cleanup:
    std::cout << "Cleaning up\n";
    
    return 0;
}

Better alternatives to goto

Alternative 1: Use structured loops

// Instead of goto for repetition, use loops
#include <iostream>

int main()
{
    bool keepRunning = true;
    
    while (keepRunning)
    {
        std::cout << "Enter a number (0 to quit): ";
        int number;
        std::cin >> number;
        
        if (number == 0)
        {
            keepRunning = false;  // Better than goto
        }
        else
        {
            std::cout << "You entered: " << number << std::endl;
        }
    }
    
    std::cout << "Program ended\n";
    return 0;
}

Alternative 2: Use functions

// Instead of goto for different sections, use functions
#include <iostream>

void processUserInput()
{
    std::cout << "Processing user input...\n";
    // Processing logic here
}

void validateData()
{
    std::cout << "Validating data...\n";
    // Validation logic here
}

void cleanupResources()
{
    std::cout << "Cleaning up resources...\n";
    // Cleanup logic here
}

int main()
{
    processUserInput();
    validateData();
    cleanupResources();
    
    return 0;
}

Alternative 3: Use early returns

// Instead of goto for early exit, use return
#include <iostream>

int processData(int value)
{
    if (value < 0)
    {
        std::cout << "Error: Negative value\n";
        return -1;  // Early return instead of goto
    }
    
    if (value == 0)
    {
        std::cout << "Warning: Zero value\n";
        return 0;   // Early return instead of goto
    }
    
    std::cout << "Processing value: " << value << std::endl;
    return value * 2;
}

int main()
{
    int result = processData(5);
    std::cout << "Result: " << result << std::endl;
    
    return 0;
}

Alternative 4: Use break and continue

// Instead of goto in loops, use break and continue
#include <iostream>

int main()
{
    for (int i = 0; i < 10; ++i)
    {
        if (i == 3)
        {
            continue;  // Skip this iteration instead of goto
        }
        
        if (i == 7)
        {
            break;     // Exit loop instead of goto
        }
        
        std::cout << "i = " << i << std::endl;
    }
    
    return 0;
}

Output:

i = 0
i = 1
i = 2
i = 4
i = 5
i = 6

Rare legitimate uses of goto

1. Breaking out of nested loops

#include <iostream>

int main()
{
    bool found = false;
    
    for (int i = 0; i < 10; ++i)
    {
        for (int j = 0; j < 10; ++j)
        {
            for (int k = 0; k < 10; ++k)
            {
                if (i * j * k == 42)
                {
                    std::cout << "Found: i=" << i << ", j=" << j << ", k=" << k << std::endl;
                    goto end_search;  // Break out of all loops at once
                }
            }
        }
    }
    
end_search:
    std::cout << "Search completed\n";
    
    return 0;
}

Better alternative using a function:

#include <iostream>

bool findTriplet()
{
    for (int i = 0; i < 10; ++i)
    {
        for (int j = 0; j < 10; ++j)
        {
            for (int k = 0; k < 10; ++k)
            {
                if (i * j * k == 42)
                {
                    std::cout << "Found: i=" << i << ", j=" << j << ", k=" << k << std::endl;
                    return true;  // Return instead of goto
                }
            }
        }
    }
    return false;
}

int main()
{
    findTriplet();
    std::cout << "Search completed\n";
    
    return 0;
}

2. Error handling in C-style code (resource cleanup)

#include <iostream>
#include <fstream>

int processFile(const char* filename)
{
    std::ifstream file;
    int* buffer = nullptr;
    int result = 0;
    
    file.open(filename);
    if (!file.is_open())
    {
        result = -1;
        goto cleanup;  // Skip to cleanup on error
    }
    
    buffer = new int[1000];
    if (!buffer)
    {
        result = -2;
        goto cleanup;  // Skip to cleanup on error
    }
    
    // Process file...
    std::cout << "File processed successfully\n";
    
cleanup:
    if (buffer)
    {
        delete[] buffer;
    }
    
    if (file.is_open())
    {
        file.close();
    }
    
    return result;
}

int main()
{
    int result = processFile("test.txt");
    std::cout << "Result: " << result << std::endl;
    
    return 0;
}

Better C++ alternative using RAII:

#include <iostream>
#include <fstream>
#include <memory>

int processFile(const char* filename)
{
    std::ifstream file(filename);
    if (!file.is_open())
    {
        return -1;  // Early return on error
    }
    
    auto buffer = std::make_unique<int[]>(1000);
    if (!buffer)
    {
        return -2;  // Early return on error
    }
    
    // Process file...
    std::cout << "File processed successfully\n";
    
    return 0;  // RAII handles cleanup automatically
}

int main()
{
    int result = processFile("test.txt");
    std::cout << "Result: " << result << std::endl;
    
    return 0;
}

Goto restrictions and limitations

1. Cannot jump into scopes

#include <iostream>

int main()
{
    goto skip;  // ERROR: Cannot jump into a scope
    
    {
        int x = 10;
    skip:
        std::cout << x << std::endl;  // x is not accessible
    }
    
    return 0;
}

2. Cannot jump over variable initializations

#include <iostream>

int main()
{
    goto skip;  // ERROR: Jumps over initialization
    
    int x = 42;  // This initialization is skipped
    
skip:
    std::cout << x << std::endl;  // x is uninitialized
    
    return 0;
}

3. Cannot jump between functions

void function1()
{
    goto other_function;  // ERROR: Cannot jump to other functions
}

void function2()
{
other_function:
    std::cout << "This won't work\n";
}

Structured programming alternatives

State machines

#include <iostream>

enum class State
{
    Start,
    Processing,
    Validation,
    Cleanup,
    End
};

int main()
{
    State currentState = State::Start;
    bool running = true;
    
    while (running)
    {
        switch (currentState)
        {
            case State::Start:
                std::cout << "Starting process...\n";
                currentState = State::Processing;
                break;
                
            case State::Processing:
                std::cout << "Processing data...\n";
                currentState = State::Validation;
                break;
                
            case State::Validation:
                std::cout << "Validating results...\n";
                currentState = State::Cleanup;
                break;
                
            case State::Cleanup:
                std::cout << "Cleaning up...\n";
                currentState = State::End;
                break;
                
            case State::End:
                std::cout << "Process complete\n";
                running = false;
                break;
        }
    }
    
    return 0;
}

Exception handling

#include <iostream>
#include <stdexcept>

void processData(int value)
{
    if (value < 0)
    {
        throw std::invalid_argument("Negative values not allowed");
    }
    
    if (value == 0)
    {
        throw std::runtime_error("Zero value causes division error");
    }
    
    std::cout << "Processing value: " << value << std::endl;
    std::cout << "Result: " << (100 / value) << std::endl;
}

int main()
{
    try
    {
        processData(5);
        processData(0);   // This will throw an exception
        processData(-1);  // This won't be reached
    }
    catch (const std::exception& e)
    {
        std::cout << "Error: " << e.what() << std::endl;
    }
    
    return 0;
}

Output:

Processing value: 5
Result: 20
Error: Zero value causes division error

Modern C++ best practices

1. Use RAII for resource management

#include <iostream>
#include <memory>
#include <fstream>

class FileProcessor
{
private:
    std::unique_ptr<std::ifstream> file;
    std::unique_ptr<int[]> buffer;
    
public:
    bool initialize(const std::string& filename)
    {
        file = std::make_unique<std::ifstream>(filename);
        if (!file->is_open())
        {
            return false;
        }
        
        buffer = std::make_unique<int[]>(1000);
        return true;
    }
    
    void process()
    {
        if (file && buffer)
        {
            std::cout << "Processing file with RAII\n";
        }
    }
    
    // Destructor automatically cleans up resources
    ~FileProcessor() = default;
};

2. Use structured bindings and modern control flow

#include <iostream>
#include <tuple>
#include <optional>

std::optional<std::tuple<int, int, int>> findTriplet()
{
    for (int i = 0; i < 10; ++i)
    {
        for (int j = 0; j < 10; ++j)
        {
            for (int k = 0; k < 10; ++k)
            {
                if (i * j * k == 42)
                {
                    return std::make_tuple(i, j, k);  // Early return with value
                }
            }
        }
    }
    return std::nullopt;  // Not found
}

int main()
{
    if (auto result = findTriplet())
    {
        auto [i, j, k] = *result;  // Structured binding
        std::cout << "Found: i=" << i << ", j=" << j << ", k=" << k << std::endl;
    }
    else
    {
        std::cout << "Triplet not found\n";
    }
    
    return 0;
}

Summary

Goto statements and modern alternatives:

Problems with goto:

• Creates hard-to-follow "spaghetti code"
• Breaks structured programming principles
• Makes debugging and maintenance difficult
• Reduces code readability and understandability

Better alternatives:

• Structured loops for repetition
• Functions for organizing code sections
• Early returns for early exits
• Break and continue for loop control
• Exception handling for error management
• RAII for resource management
• State machines for complex flow control

Rare legitimate uses:

• Breaking out of deeply nested loops (though functions are usually better)
• Resource cleanup in C-style code (though RAII is better in C++)

Modern C++ approach:

• Use structured programming constructs
• Leverage RAII for automatic resource management
• Use exceptions for error handling
• Employ modern C++ features like std::optional and structured bindings

The consensus in modern programming is to avoid goto statements almost entirely. The structured programming alternatives are clearer, safer, and more maintainable.

Quiz

1. What does a goto statement do?
2. Why is goto generally discouraged in modern programming?
3. What is "spaghetti code" and how does goto contribute to it?
4. What are better alternatives to using goto for early exit from functions?
5. Can you use goto to jump between different functions?

Practice exercises

1. Goto elimination: Take this goto-heavy code and rewrite it using structured programming:

   int main() {
       int x = 1;
   start:
       if (x > 10) goto end;
       if (x % 2 == 0) goto skip;
       std::cout << x << " ";
   skip:
       x++;
       goto start;
   end:
       return 0;
   }
   

2. Nested loop breaking: Write a program that searches for a specific pattern in a 3D array. First implement it with goto, then rewrite it using a function with early return.

3. State machine: Convert a goto-based state machine into a proper switch-based state machine that processes user commands.

4. Error handling: Create a file processing function that handles multiple error conditions. Show both a goto-based approach and a modern C++ RAII-based approach.