Thread: mixing code with declarations

If anybody knows the section in C89 where this is explained, please tell.

I don't know C standard but would you be surprised if this compiled without warnings?

Code:

int p = 1;
int er = 2;

So, what's the difference?

The difference is that (I thought) the stack would be constructed in one swoop, like resetting the stack pointer or something. So it would make sense to put it in the language that all the variables must be declared at the beginning of the scope, so that stack allocation optimization would be easy. Initialization of constants is just a memcpy or zero-fill, also easily optimized.

But when you have returns from functions, the initialization's value is indeterminate, so you can't optimize it. So it would have to be just a regular assignment operation.

So what is the difference between:

Code:

#include <stdio.h>
int func(int i){return i++;}
int main()
{
	int p = getchar();
	int er = func(p);
	er++ && p++; /* silence warnings */
	return 0;
}

which C89 allows... and

Code:

#include <stdio.h>
int func(int i){return i++;}
int main()
{
	int p;
        p = getchar();
	int er = func(p);
	er++ && p++; /* silence warnings */
	return 0;
}

which C89 does not allow?

If you allow function initializations, why not allow declarations interspersed with code?

I have no idea what the reasoning is, but yes, robwhit's first example is correct, the second one will not compile in C89.

--
Mats

Originally Posted by robwhit

I've been thinking about this and I think I'll answer my own question.

Using function initializations does not preclude the compiler from allocating the stack in one swoop. It could do that, with the variables rearranged to have consecutive zero-filled variables and memcpy'ied variables, respectively.

Then the function inits would be called and performed after the declaration block, like they would have if they were in code and not in the declaration block. That way, you get optimizations and function initializations.

Originally Posted by robwhit

Thanks!

I guess that makes sense...

You thank yourself for answering your own question?

Anyway, I'm not sure the C language would be entirely defined with specific compiler optimizations in mind. I thought that local uninitialized variables were not zero-filled or anything.

Logically, if you initialize a variable with the return value of a function, you do run code - but in a different function. If initializing with a literal or another variable is acceptable, there seems no reason to disallow initializing with the return value of a function call.

Originally Posted by anon

You thank yourself for answering your own question?

I think robwit typed up his first response before noticing matsp's response, and then posted a new post replying to matsp. You're right, it does look funny at first, though. (That's what the edit button is for . . . .)

Either that or robwit has a split personality or something, or (more likely) more than one person is using his account. Nah, probably not.

Anyway, I'm not sure the C language would be entirely defined with specific compiler optimizations in mind. I thought that local uninitialized variables were not zero-filled or anything.

Yes, that is true. But the increment operator ++ exists mostly because the original PDP-10s or whatever the model number was had an instruction for it, at a time when most other computers did not. IIRC.

Logically, if you initialize a variable with the return value of a function, you do run code - but in a different function. If initializing with a literal or a simple variable is acceptable, there seems no reason to disallow initializing with the return value of a function call.

Yeah, well, what about this?

Code:

int period = use_radians() ? atan(1.0)*4.0 : 360.0

Looks like code to me.

As for the original question: I'm not sure why it works, either. However, I'm pretty sure that the compiler treats

Code:

int x = 3, y = 4;

as

Code:

int x, y;
x = 3, y = 4;

But that's just an impression.

I have a strong feeling that the C language parser becomes quite a lot easier to write when you don't have to check if a line is a variable declaration as well as parse regular function calls etc. This is probably a large part of the reasoning. Of course, wich C++ arriving, the compiler had to support "variables declared anywhere", so it was quite easy to back-port that into the regular C compiler, hence the C99 allows this.

--
Mats