C goto Statement

What You’ll Learn

The goto statement jumps to a label in the same function—no condition attached. Most beginner code should use if, loops, and break instead, but goto still appears in cleanup patterns and for escaping deeply nested loops. This tutorial explains syntax, legitimate uses, pitfalls, five examples, and when not to use it.

Definition and Usage

The goto statement transfers control to a labeled statement in the same function. A label is an identifier followed by a colon (done:). The jump is unconditional—unlike if, nothing is tested at the goto itself.

Structured programming favors if, for, while, and functions. Still, you may see goto in Linux kernel code and in centralized cleanup blocks that free memory or close files after failures. Know what it does; use it only when the benefit is clear.

📝 Syntax

General form of goto and a label:

goto label_name;
/* ... other statements ... */
label_name:
    statement;

Rules

• Same function — label and goto must live in one function.
• Forward or backward — both directions are legal in C.
• Label scope — visible throughout the enclosing function.
• Not into a block — cannot jump into the middle of a scope that skipped initialization (compiler may reject).

Compile

gcc program.c -std=c11 -o program

Examples Gallery

Compile with gcc example.c -std=c11 -o example. Each program shows a different goto pattern—study them, but prefer structured code in your own projects.

#include <stdio.h>

int main(void) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (i == 1 && j == 1) {
                goto exit_loops;
            }
            printf("i = %d, j = %d\n", i, j);
        }
    }

exit_loops:
    printf("Exited the loops\n");

    return 0;
}

i = 0, j = 0
i = 0, j = 1
i = 0, j = 2
i = 1, j = 0
Exited the loops

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    FILE *file = fopen("missing.txt", "r");

    if (file == NULL) {
        goto error;
    }

  /* would read/process file here */
    fclose(file);
    return 0;

error:
    fprintf(stderr, "Failed to open the file\n");
    return 1;
}

Failed to open the file

#include <stdio.h>

int main(void) {
    int n = -5;

    if (n < 0) {
        printf("Invalid input: %d\n", n);
        goto end;
    }

    printf("Processing %d...\n", n);
    printf("Done processing.\n");

end:
    printf("Program finished.\n");

    return 0;
}

Invalid input: -5
Program finished.

#include <stdio.h>

int main(void) {
    int grid[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int target = 5;
    int found_row = -1, found_col = -1;

    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 3; c++) {
            if (grid[r][c] == target) {
                found_row = r;
                found_col = c;
                goto found;
            }
        }
    }

found:
    if (found_row >= 0) {
        printf("Found %d at row %d, col %d\n", target, found_row, found_col);
    } else {
        printf("%d not found\n", target);
    }

    return 0;
}

Found 5 at row 1, col 1

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *a = NULL;
    int *b = NULL;
    int status = 0;

    a = malloc(10 * sizeof *a);
    if (a == NULL) {
        status = 1;
        goto cleanup;
    }

    b = malloc(10 * sizeof *b);
    if (b == NULL) {
        status = 2;
        goto cleanup;
    }

    a[0] = 42;
  printf("Allocated and used both buffers.\n");

cleanup:
    free(b);
    free(a);
    if (status != 0) {
        printf("Cleanup after error code %d\n", status);
    }

    return status;
}

Allocated and used both buffers.

🚀 Common Use Cases

• Nested loop exit — leave two or more loops at once.
• Resource cleanup — one block frees memory, closes files.
• Error paths — jump to shared failure handling in long functions.
• Kernel/driver code — low-level C where structured escape is awkward.
• Generated parsers — some tools emit goto for state machines.
• Avoid in app logic — menus and business rules belong in if/switch.

📝 Notes

• goto cannot cross function boundaries.
• Labels do not change scope—variables declared after a label were not initialized if you jumped over their declaration.
• Dijkstra’s famous note argued against unrestricted goto; modern style favors structure.
• break and continue are not substitutes for cross-function exit—use return.
• Name labels clearly: cleanup:, error:, not single letters in large files.
• This is the last tutorial in the control statements series.

⚡ Optimization

goto is a direct jump at machine level—no meaningful speed advantage over well-written if and loops on modern compilers. Readability and maintainability matter far more. Choose structure over micro-optimization.

💡 Best Practices