Thread: Looping & stacks

When creating a variable used within a loop, is it quicker/more effecient to redefine the variable every loop repetition or define it once in a higher scope? I.E.:

Code:

while(p != NULL)
{
  char buf[BUFSIZ];
  strcpy(buf, p->str);
}

vs.

Code:

char buf[BUFSIZ];
while(p != NULL)
{
   strcpy(buf, p->str);
}

So in the former, buf is being redefined every iteration, which may maximize the use of space, but in the latter, time is not wasted setting up space again and again (however, buf must still at least be passed on the stack, right?). So I'm wondering if there really is a space/speed tradeoff between the two? Which is faster? more effecient? Or does it even really matter if you have an optimizing compiler (i.e. gcc (-O3))?

Code:

#include <stdio.h>

int main(void)
{
	int i;
	for(i=0;i<100;i++)
	{
		char szBuffer[1000];
		strcpy(szBuffer,"bleh");
		printf("szBuffer = &#37;s\n",szBuffer);
	}
	return 0;
}

Code:

        .file   "tehlocal.c"
        .def    ___main;        .scl    2;      .type   32;     .endef
        .section .rdata,"dr"
LC0:
        .ascii "bleh\0"
LC1:
        .ascii "szBuffer = %s\12\0"
        .text
.globl _main
        .def    _main;  .scl    2;      .type   32;     .endef
_main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $1064, %esp
        andl    $-16, %esp
        movl    $0, %eax
        addl    $15, %eax
        addl    $15, %eax
        shrl    $4, %eax
        sall    $4, %eax
        movl    %eax, -1036(%ebp)
        movl    -1036(%ebp), %eax
        call    __alloca
        call    ___main
        movl    $0, -12(%ebp)
L2:
        cmpl    $99, -12(%ebp)
        jg      L3
        movl    $LC0, 4(%esp)
        leal    -1032(%ebp), %eax
        movl    %eax, (%esp)
        call    _strcpy
        leal    -1032(%ebp), %eax
        movl    %eax, 4(%esp)
        movl    $LC1, (%esp)
        call    _printf
        leal    -12(%ebp), %eax
        incl    (%eax)
        jmp     L2
L3:
        movl    $0, %eax
        leave
        ret
        .def    _printf;        .scl    3;      .type   32;     .endef
        .def    _strcpy;        .scl    3;      .type   32;     .endef

Compiled the .c file with the -S switch on MinGW, and the assembly file is what was provided. All local variables have been allocated at the beginning of the function. Therefore, I would say you're not getting a real performance increase or decrease by allocating the buffer anywhere. At this point, you'd dealing with good C coding practice for readability, maintainability, etc. etc..

In case there is any doubt, I compiled it with the buffer declared before i, and the assembly output was almost identical.

I'm not really sure what you think you're gaining by using the first method anyway.

Thanks for that, its good to know the compiler does the optimization. What I was thinking for the first method was that if space was allocated for buf inside of the loop (L2) than precisely right after the jmp call to L2 and before the PC goes back to L2, the space allocated for buf will be removed off the stack and you will have saved sizeof(buf) more space in memory. Of course the time between the jmpl and when the PC is actually moved back to L2 is probably insignificantly short, and probably only another process running as a seperate thread could actually make use of the memory saved.
Other than that, I prefer the first method mostly for readability, as it is more clear as to when buf is actually being used. Out of curiousity what do you (all) use in this situation?

I really don't think you're saving much space by doing it that way, especially since you're talking about the stack. The overhead just seems to be too much of a waste to try to save 512 bytes, or even 8192 bytes, or whatever BUFSIZ is on your system in this manner.

I prefer to declare all my local variables at the beginning of the function, although just in recent days, I've been making an exception for programs that need long switch statements where certain local variables need only to be used in perhaps one case. Eventually, I think I moved most or all them to the top of the function anyway, so, I guess that exception doesn't count.

The first method can save you from the occasional error:
buffer is declared before loop, initialized inside the loop and accessed after the loop (that should not be here - for example misspelled name).
If loop is never executed - you access (by mistake) not initialized variable...

If yo umove declaration of the buffer inside the loop - compiler will warn you about access to the not declared variable... And you can fix the access to the right variable immediately...

So I always prefer to declare the variables in the minimum scope possible. (Sometimes even bringing additional scopes with

Code:

{}

without if or loop)

So your saying all variables in a program, regardless of their scope, are reserved space on the stack at run-time? Even across different modules?
This seems to contradict what I recall (a very informed) someone warning that, in C99 mode, declaring variables anywhere other than the top of the stack could potentially generate problems if not enough memory could be allocated for that variable in mid-execution? According to the above, this would never be a problem, since all variables are allocated at run-time, right?

brewbuck is saying that variables local to functions are reserved when the function starts, not at program start.

I would kind of hope that a compiler would not allow mid-declaration statements to actually allocate memory more than once from the stack. I can't see a real reason why you would want to do that.