Why does Microsoft's C compiler want the variables at the beginning of the function?

Question

I am currently writing a C (not C++). It seems the Microsoft's C compiler requires all variables to be declared on top of the function.

For example, the following code will not pass compilation:

int foo(int x) {
    assert(x != 0);
    int y = 2 * x;
    return y;
}

The compiler reports an error at the third line, saying

error C2143: syntax error : missing ';' before 'type'

If the code is changed to be like below it will pass compilation:

int foo(int x) {
    int y;
    assert(x != 0);
    y = 2 * x;
    return y;
}

If I change the source file name from .c to be .cpp, the compilation will also pass as well.

I suspect there's an option somewhere to turn off the strictness of the compiler, but I haven't found it. Can anyone help on this?

Thanks in advance.

I am using cl.exe that is shipped with Visual Studio 2008 SP1.

Added:

Thank you all for answering! It seems I have to live in C89 with Microsoft's cl.exe.

Answer 1

It looks like it's using C89 standard, which requires that all variables be declared before any code. You may initialize them with literals, etc., but not mix code and variables.

There should be a compiler flag to enable C99 somewhere, which will get you the behavior you're used to.

EDIT: quick Googling does not look promising for enabling C99. You may have to live with C89 (which ain't so bad) or find a better C compiler (which would be better).

Answer 2

The C89 standard, which you must be using based on this error, requires the variables to be declared before you start executing statements in any block.

You won't be having this problem with .cpp extension files because the compiler will be treating these as C++ files, which doesn't have the same restriction.

Your assert statement is code so you can't declare a variable after that (in the same block/scope).

Technically you could do this:

int foo(int x) {
    assert(x != 0);
    {
        int y = 2 * x;
        return y;
    }
}

but I wouldn't advise it.

Answer 3

I don't know for C99 but for earlier versions of the language local variables must be declared at the beginning of a { } block.

Answer 4

In C90, all variables have to be declared before the first statement. This is not the case in C99. I suppose you can see if the compiler has a switch for C99.

Answer 5

The C spec requires that all variables be declared prior to the first line of executable code. The compiler is adhering to the spec. Some compilers are lenient in this regard.

Answer 6

It makes it easier to translate to assembly. All the variables are pushed onto the stack when you enter the function, so you don't have to worry about doing it anywhere else.

Answer 7

Microsoft C compiler is C89 compilant, and isn't upgraded anymore, the standard C99 isn't afaik planned. For plain C in C99 (variables not on begin of block) use another compiler, or C++ extension.

Answer 8

Agree with the comment about the C spec. Remember that C was created in a time when computers didn't have a lot of memory.

One way to deal with that was to make sure that a source file could be read in a single pass from top to bottom (which is also the reason why .h-files are used -> they tell the code that certain functions do indeed exist, but possibly somewhere after the first time that they are referenced).

It's probably easier to create a compiler for code that declares variables at the top of a scope than it is for code that can declare variables anywhere.

Answer 9

As others have said, this is just the version of C which MSC supports. However, if you're prepared to offend the purists, you can just force the compiler to compile as C++.

This will make very little difference to pure C (there are some rules about casting void* pointers, and name decoration changes), but might give you a useful hybrid. The code generated will be much the same - there is no magical loss (or gain) of efficiency by making this change.

You don't say why you're keen to use C.

Answer 10

It's a shame that MS doesn't implement mixed declarations and statements as an extension to the C compiler (even if it's off by default and needs to be switched on). I'm not certain, but I think it's a pretty common extension in other non-C99 C compilers; it seems like often enough I have to fix up source and samples to compile in MSVC.

I'd think it would be relatively easy to implement, since of course they already do it for C++.