Is there a way to write such program without using goto?

Question

Is there a way to write such program without using goto? If so, how?

Answer 1

"Is there a way to write such program without using goto?"
-- Philip Moreira

Yes. Technically speaking, C++ is flexible enough that you can forbid pretty much any one construct and still be able to implement what you want, including goto.

The "how" part is a bit uninteresting, so let's just say you'd do that by taking two loops, using additional flag variables in one of the conditions so it doesn't behave like a loop anymore, and carefully use if to end up with something that meets the specification.

"Yes, but is there a way to naturally model this flowchart with only high-level flow control?"
-- Helpful voice-over

No.

This is actually one of the canonical cases where C++'s high-level constructs are not enough. All of them are designed around a concept of nested scopes (exception handling can cut a scope short, but that's it). This flowchart features two crossed loops, with just enough operations in-between that you can't just shuffle them around to get nested loops.

You have two choices:

• Just use goto. Document it, make the label explicit, and apply other usual good practices.

• Try to stick to the "no goto" rule to hell and forth, bending other control structures out of shape until you have effectively emulated a goto, with a side serving of rogue booleans and tricky conditions.

The second solution might end up more legible than the first (never say "never", they say), but you definitely shouldn't discard the first one before trying.

For reference, here is how you would translate your flowchart (actions and conditions numbered from their order in the flowchart):

action_one;

properlyNamedLabel:
action_two;

do {
    action_three;

    if(condition_one)
        goto properlyNamedLabel;

    action_four;

} while(condition_two);

action_five;

Answer 2

This is one of many potential solutions, which your compiler could make as efficient as using gotos.

One branch is handled in a do/while condition. The other branch is handled by a return.

bool func();

int main()
{
     statement1();
     while( func() ) {}
     statement5();
}

bool func()
{
     statement2();
     do
     {
         statement3();
         if ( condition1() )
         {
             return true;
         }
         statement4();
     } while( condition2() )
     return false;
}

You may notice by viewing the code that the logic is rather complex.

In a real-world program, this may be a sign that the program logic needs to be reviewed.

Answer 3

I don't think anyone would ever attempt to do this flow chart "as is" - but with some modifications it could be made.

The first loop is clearly a do {} while(). Let us pull that out into a function for now to make our life easy. The second loop wants us to jump into the middle of the do while. Well, rather than do this with goto's; it's nicer for us to call our function; with a flag to not do the first thing.

Note that I have used the 2nd task in the flow chart as my 1st; since it's the first in a loop.

As such you end up with something like

void myFirstLoopFunc(bool doFirstTask) {
    do {
        if (doFirstTask)
            firstTask();
        doFirstTask = true;
        secondTask();
    }
    while(firstTest());
}

void mySecondLoopFunc() {
    bool doFirstThing = true;
    do {
        myFirstLoopFunc(doFirstThing);
        thirdTask();
        doFirstThing = false;
    } while (secondTest());
}

One would then call mySecondLoopFunc to start the chain.