Labels and goto - D Programming Language
Description: D Programming Language
Keywords: D programming language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Discord (community-run)
  - Forums
  - IRC
  - Wiki
  - Issues
  - Contributing
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a GitHub issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# Labels and goto

Labels are names given to lines of code in order to direct program flow to those lines later on.

A label consists of a name and the `:` character:

    end:   // ← a label

That label gives the name end to the line that it is defined on.

Note: In reality, a label can appear between statements on the same line to name the exact spot that it appears at, but this is not a common practice:

        anExpression(); end: anotherExpression();

##### `goto`

`goto` directs program flow to the specified label:

    void foo(bool condition) {
        writeln("first");

        if (condition) {
            goto end;
        }

        writeln("second");

    end:

        writeln("third");
    }

When `condition` is `true`, the program flow goes to label `end`, effectively skipping the line that prints "second":

    first
    third

`goto` works the same way as in the C and C++ programming languages. Being notorious for making it hard to understand the intent and flow of code, `goto` is discouraged even in those languages. Statements like `if`, `while`, `for` etc. should be used instead.

For example, the previous code can be written without `goto` in a more structured way:

    void foo(bool condition) {
        writeln("first");

        if (!condition) {
            writeln("second");
        }

        writeln("third");
    }

However, there are two acceptable uses of `goto` in C, none of which is necessary in D.

###### Finalization area

One of the valid uses of `goto` in C is going to the finalization area where the cleanup operations of a function are performed (e.g. giving resources back, undoing certain operations, etc.):

    // --- C code ---

    int foo() {
        // ...

        if (error) {
            goto finally;
        }

        // ...

    finally:
        // ... cleanup operations ...

        return error;
    }

This use of `goto` is not necessary in D because there are other ways of managing resources: the garbage collector, destructors, the `catch` and `finally` blocks, `scope()` statements, etc.

Note: This use of `goto` is not necessary in C++ either.

###### `continue` and `break` for outer loops

The other valid use of `goto` in C is about outer loops.

Since `continue` and `break` affect only the inner loop, one way of continuing or breaking out of the outer loop is by `goto` statements:

    // --- C code ---

        while (condition) {

            while (otherCondition) {

                // affects the inner loop
                continue;

                // affects the inner loop
                break;

                // works like 'continue' for the outer loop
                goto continueOuter;

                // works like 'break' for the outer loop
                goto breakOuter;
            }

        continueOuter:
            ;
        }
    breakOuter:

The same technique can be used for outer `switch` statements as well.

This use of `goto` is not needed in D because D has loop labels, which we will see below.

Note: This use of `goto` can be encountered in C++ as well.

###### The problem of skipping constructors

The constructor is called on an object exactly where that object is defined. This is mainly because the information that is needed to construct an object is usually not available until that point. Also, there is no need to construct an object if that object is not going to be used in the program at all.

When `goto` skips a line that an object is constructed on, the program can be using an object that has not been prepared yet:

        if (condition) {
            goto aLabel;    // skips the constructor
        }

        auto s = S(42);     // constructs the object properly

    aLabel:

        s.bar();            // BUG: 's' may not be ready for use

The compiler prevents this bug:

    Error: goto skips declaration of variable deneme.main.s

##### Loop labels

Loops can have labels and `goto` statements can refer to those labels:

    outerLoop:
        while (condition) {

            while (otherCondition) {

                // affects the inner loop
                continue;

                // affects the inner loop
                break;

                // continues the outer loop
                continue outerLoop;

                // breaks the outer loop
                break outerLoop;
            }
        }

`switch` statements can have labels as well. An inner `break` statement can refer to an outer `switch` to break out of the outer `switch` statement.

##### `goto` in `case` sections

We have already seen the use of `goto` in `case` sections in the `switch` and `case` chapter:

- `goto case` causes the execution to continue to the next `case`.
- `goto default` causes the execution to continue to the `default` section.
- `goto case expression` causes the execution to continue to the `case` that matches that expression.

##### Summary

- Some of the uses of `goto` are not necessary in D.
- `break` and `continue` can specify labels to affect outer loops and `switch` statements.
- `goto` inside `case` sections can make the program flow jump to other `case` and `default` sections.

Copyright © 1999-2026 by the D Language Foundation | Page generated by Ddoc on Wed Aug 19 13:28:53 2026