Not understanding some programming patterns

Question

When I read experienced programmers code, I realize some patterns which I would not consider optimized code. I've been searching for this on google but there's no discuss on the topic that I could find.

What is the reason behind declaring all variables at the beginning of the program? For example, why does someone use:

GtkWidget *window;

gtk_init(NULL, NULL);

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

instead of

gtk_init(NULL, NULL);

GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

Or, for example, why does one declare a variable i for a loop like

int i;
char *a;

(code)

for(i = 0; i < n; i++)

instead of declaring i just above the for loop?

char *a;

(code)

int i;
for(i = 0; i < n; i++)

I think it would be easier to read. Isn't that just giving away memory? Because until the time the for is called, there are 4 bytes in memory which are not used.

I'm not remembering other patterns that I use to see in others code but I find very often things like this that I'd like to know why are like this; specially if they are not optimized (I guess). I asked some people why they do things like this but they either tell me they were taught like that or they get offended like I shouldn't have asked that.

I genuinely interested in knowing why do programmers structure their code like this in order to understand and improve my coding. And if you have any advice on how to structure code or tips on good programming behaviours, please let me know.

Answer 1

Isn't that just giving away memory? Because until the time the for is called, there are 4 bytes in memory which are not used.

I don't think so. In the common platforms that I have worked in, Linux and Windows, the size of the stack frame is same regardless of whether you declare the variables at the top of the function or declare them as you go.

The only scenarios where declaring the variables at the top of the function will have an adverse impact is if the construction of the object is expensive.

Whether you declare them at the top of the function or declare them as you need is, most of the time, a policy decision in a development team.

Answer 2

Older versions of C (K&R C, C89) required all variables to be declared before any code within a block. It wasn't until the C99 standard that declarations could be mixed with code (C++ obviously did that a bit earlier). As for why that was the case, remember that C is a product of the early 1970s, when 256 kilowords was a lot of memory and processor speeds were orders of magnitude slower than they are today. Anything that simplified parsing and code generation was a Good Thing, and forcing you to group declarations together helped with that (note that many of C's contemporaries like Fortran and Pascal also forced all declarations to occur that the beginning of a function or a block).

As for memory, most compilers will generate code to allocate the storage for all block-scope objects at function entry, regardless of where the declaration actually occurs in the source code. IOW, the two snippets

int i;
// bunch of code here
for ( i = 0; i < 10; i++ ) 
  do_something_interesting();

and

// bunch of code here
for ( int i = 0; i < 10; i++ ) 
  do_something_interesting();

will (most likely) result in the same machine code that allocates the space for i at function entry.

The only real advantage in deferring declarations (in C, anyway) is to make the code easier to read and maintain. It has little to no effect on runtime performance (compilers may optimize a little differently based on where things are declared, but IME that doesn't happen much).

Answer 3

Any decent optimizing compiler would reduce the effective lifetime of the int or pointer in the cases you described in order to achieve any performance improvements made possible by that reduced lifetime.

So the early declaration is bad C++ style (and bad C style in modern version of C). But you would need a more difficult example for that bad style to produce less efficient code.

Someone reading the code does not have as much memory as a compiler so any variable whose declared lifetime exceeds its useful lifetime is a source of confusion to anyone trying to understand your code. Worry about that first, and (most of the time) let the compiler writers worry about the performance.

Answer 4

from http://www.dummies.com/how-to/content/declaring-variables-in-c.html: "That way, the compiler knows what the variables are called and what type of variables they are (what values they can contain)"

I think this post is relatable : Where you can and cannot declare new variables in C?