Why Do try ... catch Blocks Require Braces?

Question

Hello.

While in other statements like if ... else you can avoid braces if there is only one instruction in a block, you cannot do that with try ... catch blocks: the compiler doesn't buy it. For instance:

try
    do_something_risky();
catch (...)
    std::cerr << "Blast!" << std::endl;

With the code above, g++ simply says it expects a '{' before do_something_risky(). Why this difference of behavior between try ... catch and, say, if ... else ?

Thanks!

Answer 1

Well, first, that's how the grammar works.

Second, I would believe that the goal is to forcibly generate a new scope for the exception blocks(correct me if I'm wrong).

Answer 2

Not sure why, but one benefit is that there is no dangling-catch issue. See dangling-else for an ambiguity that can arise when braces are optional.

Answer 3

That's how they wanted to be. There is no justification, it's a law.

Answer 4

Straight from the C++ spec:

try-block:
    try compound-statement handler-seq

As you can see, all try-blocks expect a compound-statement. By definition a compound statement is multiple statements wrapped in braces.

Have everything in a compound-statement ensures that a new scope is generated for the try-block. It also makes everything slightly easier to read in my opinion.

You can check it yourself on page 359 of the C++ Language Specification

Answer 5

Not sure if you're using .NET but the CLR uses the braces as flags.

http://dotnet.sys-con.com/node/44398

From the article: "The SEH (structure exception handling) table consists of a set of clauses that describe the structure of the guarded code. The table has a set of binary flags that describe the type of exception handling clause: a Try Offset flag, which is the beginning of the guarded code block; a Try Length flag, which is the length of the guarded code; Handler Offset and Handler Length flags, which detail the beginning of the exception handler block and its length; and a Class Token or Filter Offset flag, depending on the type of Exception Handler that was defined. This information allows the CLR to determine what to do when an exception occurs. It maps out the beginning of the guarded code block, the code to execute for an exception, and special semantics related to filtering or other special circumstance."

I would assume that other frameworks do the same thing.

Answer 6

Read this link. Most of the reason appears to be about managing the scope and allocation of objects that need to be created and destroyed in case of real exceptions.

So, my guess is, the grammar writers of C++ are asking the authors of g++(or any standards complying C++ compiler) to prepare it for the worst possible cases, and g++ authors appear to have done so.

Answer 7

Mainly it's because

if (a)
    int b = 10;
else 
    int b = 5;
b += 5;

Will fail because the if...else without {} is a syntax shortcut for this

if (a) {
    int b = 10;
} else {
    int b = 5;
}
b += 5;

which explicitly tells you that int b is in a different scope than the rest of the software.

If I'm not mistaken the following also fails

a ? int b = 10 : int b = 5;
b += 5;

Granted, your compiler might optimize that code for you... but it should technically fail because of the scopes in the if/else statement.

Whenever you see {} you're defining the scope of the software.

-Stephen

Answer 8

Why? A tradeoff between safety and backwards compatibility.

The lessons learnt from if...else showed that requiring braces eliminates errors. Now, the ISO C++ people have a strong preference for backwards compatibility with C, so they didn't change the C syntax for if...else. But new constructs require braces to demarcate controlled blocks, as they won't appear in old C code and therefore backwards compatibility is not a concern.