C：内存中的循环，条件，结构

Question

This question may sound trivial but, I know that whenever a function starts executing a stack frame is created in the stack for all local variables of the function etc. but I cannot understand is what happens when a for loop starts executing or the code inside an if condition starts being executed. Seems unreasonable to think of them as being executed inside the stack frame of the function, since they have their own scope and thus their own local variables. But, they can access variables of the functions above them, thus this seems to imply that they are inside the stack frame of a function.

So can anybody clear this up for me?

Where are they actually located in memory when being executed?

The same question arises for structs, they have their own scope, and they are not pointers but just bigger 'boxes' containing integers, char*s etc.

Answer 1

A loop (or any other block-like construct, such as an if-else statement) is not similar to a function. A function is an autonomous entity. It's in itself a complete piece of computation. When you call a function, the instructions, statements and expressions of a function can only access – apart from globals – the function's local variables and parameters (the trick is that parameters can be bound to a calling function's locals, their address, etc.).

However, a loop, an if-else or any other kind of block is part of a function. It is not a separate unit of computation. They are not "called". They are simply reached and executed.

The fact that blocks have scope doesn't mean that they need a separate stack frame. A stack frame is not created when a new scope is entered. A stack frame is created when a function is called, because the stack is related to control flow management (eg frames need to save the return address of the function too.)

Yeah, allocation and destruction of variables in nested scopes can be represented by a stack, but that is not the call stack. That's rather some sort of a "scope stack", and it's purely conceptual. Let me demonstrate this with an example:

void foo()
{
    int a = 42;       // 'a' is declared and is in scope.
                      // Let's pretend its address is 0x1000.

    {
        int b = 1337; // 'b' is declared and in scope.
                      // Let's pretend its address is 0x1004.
    }

    // here, 'b' is destroyed. Nothing is "popped" out of the stack
    // at runtime – it's merely that the compiler can detect that the
    // name 'b' is not in scope anymore. And hence:

    int c = 0; // it may now reuse the former address of 'b', 0x1004,
               // for storing 'c'.
               // Each of these 3 variables reside within the same stack frame.
}

As for structs: that's something completely different, again. If you declare a variable of struct type, then a large enough chunk of memory will be allocated to hold all members of the struct in order. Memory-wise, "there is no struct". There are only members of the struct, allocated one-by-one, aligned properly. A struct is just an abstraction.

Answer 2

In practical reality, the variable exists in the main stack frame of the function. You just can't refer to it anywhere outside the sub-block in which it's declared. It's not really as if the variable is constantly created and destroyed each time through the loop. So it's more an issue of where the compiler allows you to refer to it by its name, not of its actual existence.