CODEWITHSUNDEEP
cscopecurly-braces
Jamison Dance
Jamison Dance

Reputation: 20184

Why enclose blocks of C code in curly braces?

I am looking at some C code, and have noticed it is full of these curly braces surrounding blocks of code without any sort of control structure. Take a look-see: 

//do some stuff . . .
fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC);
{
    //a block! why not?
    char *tmp_argv[3];
    tmp_argv[0] = argv[0]; tmp_argv[1] = str; tmp_argv[2] = prefix;
    t = clock();
    fprintf(stderr, "[bwa_index] Convert nucleotide PAC to color PAC... ");
    bwa_pac2cspac(3, tmp_argv);
    fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC);
}

Why would you insert blocks like this in the code? It is chock full of 'em. Is there some kind of performance benefit? Some mystical C thing? Why???

edit: This code if from BWA, a bioinformatics program that aligns small sequences to large reference ones using the Burrows-Wheeler transform, in case any of you were wondering. This code example isn't particularly relevant to the functionality of the application.

Upvotes: 68

Views: 36907

Answers (9)

Mike Weller
Mike Weller

Reputation: 45598

Another use case for this I've recently discovered is when you have open/close semantics and you want to clearly mark the 'inner' code:

f = fopen('file');
{
    // do stuff
}
fclose(f);

This works well to remind you to close/free objects and a makes the code somewhat cleaner.

Upvotes: 14

ltgbau
ltgbau

Reputation: 54

I sometimes use blocks in these cases: - To localize variables - Or to easier to read ...

Upvotes: 2

DigitalRoss
DigitalRoss

Reputation: 146073

Legacy code needed { } in order to do declarations at all

In C89, you couldn't just do int i; anywhere; declarations were only valid at the beginning of blocks.

So:

a = 1;
int i; /* error */
i = 2;

...wasn't valid, but

a = 1
if (e) {
  int i;

...was fine, as was a plain block.

The resulting style continued even after declarations became valid (C99) block-item(s), partly by inertia, partly for backwards portability, and also because it makes sense to establish a scope for new declarations.

Upvotes: 97

Paul Lalonde
Paul Lalonde

Reputation: 5050

A block is a scope that determines the lifetime of variables, as well as their visibility to the compiler. So variables that get created within a block go away when control exits the block.

It can be very handy when those variables are instances of classes with constructors and destructors.

However, in your example there is not much advantage.

Upvotes: 7

Jacob
Jacob

Reputation: 34601

Is that all of it? Maybe the programmer is using tmp_argv somewhere else in the code. I can't think of any other reason since the tmp_argv between the { and } is separate from any outside the braces.

Upvotes: 1

pgb
pgb

Reputation: 25001

The variables that you declare inside the block are local to that block. This way you may be able to redefine tmp_argv in some other place of your code (below) without conflicting with this piece of code.

Upvotes: 6

jldupont
jldupont

Reputation: 96716

To scope variables. E.g. the variable tmp_argv will only be valid between the braces.

Upvotes: 42

i_am_jorf
i_am_jorf

Reputation: 54600

It is creating a scope. Stack objects are destroyed when they go out of scope. It looks like it is doing some sort of typing, which would mean each block is something that they wanted to time. However, I don't see any scoped timer objects, so, yeah, makes no sense.

Upvotes: 6

Bostone
Bostone

Reputation: 37126

Hmm - I'm maybe off the chart here but I think local variable define inside such block will not be valid outside of the block

Upvotes: -5

Related Questions