Location>code7788 >text

C/C++ GOTO's wonderful uses

Popularity：145 ℃/2025-03-11 21:02:25

Table of contents
  • GOTO statement
  • Break out of multi-layer loop
  • The first part of the loop is skipped

GOTO statement

The goto statement in C/C++ is used to perform arbitrary jumps within a function, which is also very convenient to use. Examples are as follows:

int a() {
    int x = 0, sum = 0;
L1: if (x < 10) {
        x++;
        sum += x;
        goto L1;
    }
    return sum;
}

Just add a label somewhere inside the function, and passgoto <label>You can jump directly.

However, since the jump of goto is relatively primitive and unstructured, it is more troublesome to debug when the program is large, and the readability of the code will be greatly reduced. Therefore, in 1965, structured programming was proposed to avoid this error and make the code easier to read. Many times we try to avoid using goto statements and instead use other structured methods.

Nevertheless, there are some places where using goto statements is more efficient than structured. Several examples are given below.

Break out of multi-layer loop

The statements that jump out of the loop are break, and the statements that skip a loop are continue, but they can only jump out/skip one layer of the loop. When you need to break out of multi-layer loops, you can consider using the goto statement:

LOOP: for (...) // loop 1
  for (...) // loop 2
    for (...) // loop 3
      if (...)
        goto LOOP;

The goto statement here jumps from the third layer loop to the first layer loop, which is equivalent to executing the continue statement under the first layer loop. If you want to implement it in a structured way, you often need to use conditional variables. Nevertheless, the current loop needs to be popped out again and again:

int flag = 0;
for (...) // loop 1
  for (...) // loop 2
    for (...) { // loop 3
      if (...) {
        flag = 1;
        break;
      }
    }
    if (flag) break;
  }
}

You can see that this time, in addition to introducing oneflagIn addition to variables, two break statements were used to realize the equivalent function.

Many high-level languages ​​do not support goto statements to prevent possible problems, such as Java. However, Java supports itbreak <label>andcontinue <label>To support the jump and skip of multi-layer loops, for example, the equivalent way of writing the goto statement example in Java is togotoChange keywords tocontinue. Therefore, this usage should not be disliked.

The first part of the loop is skipped

If a loop body is divided into two parts A and B, the execution status after the loop is expanded is:

ABABABAB...ABAB

However, in many cases we may require skipping the first run A or the last run B, so the actual running situation is:

BABABAB...ABAB

The most classic example is to print an array and require no spaces at the end. You can consider using the goto statement:

void print_array(int arr[], int n) {
   int i = 0;
   if (i<n) goto PNT;
   for (; i<n; i++) {
     putchar(' '); // A
 PNT:
     printf("%d", arr[i]); // B
   }
   puts(); // Line break
 }

At this time, the loop will be perfectBABABA...BAexecutes in order to print the array. If you do not use the goto statement, you can consider two solutions:

  1. Add conditions to Part A to determine whether it is the first cycle. But in this way, judgments will be made every cycle, resulting in an unnecessary judgment process;
  2. Put the B part code directly in front of the loop. However, when there is a lot of code in Part B, this method will cause serious code duplication. Although part B can be encapsulated using functions, function calls can also bring additional overhead.

In contrast, using goto statements in this case does not affect the loop body code at all and is more efficient.

Note that in this case, the loop condition statements of the loop body are required to be as simple as possible (in most cases, simple as in this case.i<n), because for, while, and other loops will be judged once before entering the loop, this writing method usually adds an if statement before goto to make the same loop judgment. If the judgment statement is too long and too complicated, it will also cause certain code redundancy. Of course, for the do-while loop, the loop condition is to judge after each loop, and there is no need to make a judgment before the goto jump.

In addition, when writing code, if you want to achieveABABAB...ABAThe effect of , that is, skipping the second half of the last cycle, the order of A and B should be changed directly in the loop body, and the first half of the first cycle should be skipped with the goto statement.

Original address:/RainbowC0/p/18765900, reproduction is prohibited without the author's permission.

<Previous Next>