Skip to main content
Engineering LibreTexts

13.4: Branching Control Structures

  • Page ID
    10320
  • Discussion

    The branching control structures allow the flow of execution to jump to a different part of the program. The common branching control structures that are used with other control structures are: break, continue and goto. These are rarely used in modular structured programming with one exception. That exception is in relation to creating the case within the selection category of control structures. Within C++ the break is used with the switch to create a structure that acts like the traditional case structure. There is one other branching control structure that is often not viewed as branching control structure. It is: return; which is used with functions. Thus, there are two commonly used branching control reserved words used in C++; break and return. Additionally, we will add to our list of branching items a pre-defined function commonly used in the C++ programming language of: exit; that is part of the C standard library (cstdlib).

    Examples

    Break

    The break is used in one of two ways; with the switch (a C++ programming structure) to make it act like a case structure (it's more common name within most programming languages) or as part of a looping process to break out of the loop. The first usage is allowed in good structured programming and the second is not allowed in good structured programming.

    C++ source code
    switch (age)
      {
      case 18: cout << "\nYou can vote.";
               break;
      case 39: cout << "\nYou are middle aged.";
               break;
      case 65: cout << "\nYou are at retirement age.";
               break;
      default: cout << "\nYour current age is not important.";
      } 
    

    The following is an unauthorized use of break in a loop and it gives the appearance that the loop will execute 8 times, but the break statement causes it to stop during the fifth iteration.

    C++ source code
    counter = 0;
    while(counter < 8)
      {
      cout << counter << endl;
      if (counter == 4)
        {
        break;
        }
      counter++;
      } 
    
    Continue

    The continue structure is not allowed in good structured programming. The following gives the appearance that the loop will print to the monitor 8 times, but the continue statement causes it not to print number 4.

    C++ source code
    for(counter = 0; counter < 8; counter++)
      {
      if (counter == 4)
        {
        continue;
        }
      cout << counter << endl;
      } 
    
    Goto

    The goto structure is not allowed in good structured programming. It is with a certain amount of hesitancy that we even show it. Many textbooks do not cover the goto. Within the C++ programming language you create a label with an identifier name followed by a colon. You use the command word goto followed by the label. A label can be used before it is declared.

    C++ source code
    some lines of code;
    goto mynewspot;                //jumps to the label
    some lines of code;
    some lines of code;
    some lines of code;
    mynewspot: some statement;     //Declared label
    some lines of code; 
    
    Return

    The return is allowed in good structured programming, but only at the end of a function. A function should not pre-maturely end by having the logic of the function have it terminate by jumping back to the function that called it.

    C++ source code
    //******************************************************
    // get data
    //******************************************************
    
    void get_data(void)
      {
      // Input - Test Data - 5678.9, 5432.1
      cout << "\nEnter the length of the property in feet --->: ";
      cin >> property_length;
      cout << "\nEnter the width of the property in feet ---->: ";
      cin >> property_width;
      return;
      } 
    
    Exit

    Although exit is technically a pre-defined function, it is covered here because of its common usage in programming. A good example is the opening a file and then testing to see if the file was actually opened. If not, we have an error that usually indicates that we want to pre-maturely stop the execution of the program. Within the C++ programming language the exit function terminates the running of the program and in the process returns an integer value back to the operating system. It fits the definition of branching which is to jump to some other place in the program. In our example the value returned to the operating system is the value of the constant named: EXIT_FAILURE.

    C++ source code
    inData.open(filename);  //Open input file
    if (!inData)            //Test to see if file was opened
      {
      cout << "\n\nError opening file: " << filename << "\n\n";
      pause();              //Pause - user reads message
      exit(EXIT_FAILURE);   //Allows a pre-mature jump to OS
      } 
    

    Definitions

    Branching Control Structures
    Allow the flow of execution to jump to a different part of the program.
    Break
    A branching control structure that terminates the existing structure.
    Continue
    A branching control structure that causes a loop to stop its current iteration and begin the next one.
    Goto
    A branching control structure that causes the logic to jump to a different place in the program.
    Return
    A branching control structure that causes a function to jump back to the function that called it.
    Exit
    A pre-defined function used to prematurely stop a program and jump to the operating system.