Should break/continue/return be interrupted by an exception?

Question

I came upon an interesting scenario with flow control while working on my language. What happens if an exception is thrown while processing a break statement. GCC seems to believe the break flow is lost, but the standard seems somewhat silent on what should happen.

For example, what should the following program actually do?

#include <iostream>
using namespace std;

struct maybe_fail {
    bool fail;
    ~maybe_fail() {
        if( fail )
            throw 1;
    }
};

int main() {
    for( int i=0; i < 6; ++i ) {
        cout << "Loop: " << i << endl;

        try {
            maybe_fail mf;
            mf.fail = i % 2;
            if( i == 3 )
                break;

        } catch( int ) {
            cout << "Caught" << endl;
        }
    }
    return 0;
}

Note that a return will also be blocked, as will a continue (add output after the catch to see that). Attempt to goto outside of the block will also be caught.

What is the correct flow? The standard doesn't seem to address this: section 6.6 on jump statements makes no mention, neither does section 15 on exception handling. I do understand that exceptions in destructors is in terribly bad form, but if you are using something like BOOST_SCOPE_EXIT for defer statements this behaviour might become quite important.

Perhaps of interest, the same flow happens in Java and Python, so at least there seems to be some consistency in the imperative languages.

Answer 1

This is covered in 15.1 Throwing an exception:

2 When an exception is thrown, control is transferred to the nearest handler with a matching type (15.3); “nearest” means the handler for which the compound-statement or ctor-initializer following the try keyword was most recently entered by the thread of control and not yet exited.

Once control is transferred to the exception handler, it just continues from there. There is no mechanism to "remember" that the code was in the middle of a break and then somehow resume that after the exception is handled.