CODEWITHSUNDEEP
c++c
Zephyr
Zephyr

Reputation: 1621

Block Structure memory allocation for variables

for(int i=0;i<10;i++)
{
  int x=0;
  printf("%d",x);
   {
     int x=10;
     printf("%d",x);
   }
  printf("%d",x);
}

Here I want to know if memory for variable x will be allocated twice or is the value just reset after exiting the 2nd block and memory is allocated only once (for x) ?

Upvotes: 4

Views: 347

Answers (4)

Persixty
Persixty

Reputation: 8589

Setting aside compiler optimization that might remove these unused variables, the answer is twice.

The second definition of x masks (technical term) the other definition in its scope following its declaration. But the first definition is visible again after that scope. So logically (forgetting about optimization) the first value of x (x=0) has to be held somewhere while x=10 is 'in play'. So two pieces of storage are (logically) required.

Execute the C program below. Typical partial output:

A0 x==0 0x7ffc1c47a868
B0 x==0 0x7ffc1c47a868
C0 x==10 0x7ffc1c47a86c
D0 x==0 0x7ffc1c47a868
A1 x==0 0x7ffc1c47a868
B1 x==0 0x7ffc1c47a868
C1 x==10 0x7ffc1c47a86c
//Etc...

Notice how only point C sees the variable x with value 10 and the variable with value 0 is visible again at point D. Also see how the two versions of x are stored at different addresses. Theoretically the addresses could be different for each iteration but I'm not aware of an implementation that actually does that because it is unnecessary. However if you made these non-trival C++ objects their constuctors and destructors would get called on each loop though still reside at the same addresses (in practice).

It is obviously confusing to human readers to hide variables like this and it's not recommended.

#include <stdio.h>

int main(void) {
    for(int i=0;i<10;i++)
    {
        int x=0;
        printf("A%d x==%d %p\n",i,x,&x);
        {
            printf("B%d x==%d %p\n",i,x,&x);
            int x=10;
            printf("C%d x==%d %p\n",i,x,&x);
        }
        printf("D%d x==%d %p\n",i,x,&x);
    }
}

Upvotes: 3

JeremyP
JeremyP

Reputation: 86651

From the point of view of the C programming model, the two definitions of x are two completely different objects. The assignment in the inner block will not affect the value of x in the outer block.

Moreover, the definitions for each iteration of the loop count as different objects too. Assigning a value to either x in one iteration will not affect the x in subsequent iterations.

As far as real implementations are concerned, there are two common scenarios, assuming no optimisation is done. If you have optimisation turned on, your code is likely to be discarded because it's quite easy for the compiler to figure out that the loop has no effect on anything outside it except i.

The two common scenarios are

  1. The variables are stored on the stack. In this scenario, the compiler will reserve a slot on the stack for the outer x and a slot on the stack for the inner x. In theory it ought to allocate the slots at the beginning of the scope and deallocate at the end of the scope, but that just wastes time, so it'll reuse the slots on each iteration.

  2. The variables are stored in registers. This is the more likely option on modern 64 bit architectures. Again, the compiler ought to "allocate" (allocate is not really the right word) a register at the beginning of the scope and "deallocate" at the end but, it'll just reuse the same registers in real life.

In both cases, you will note that the value from each iteration will be preserved to the next iteration because the compiler uses the same storage space. However, never do this

for (int i = 0 ; i < 10 ; ++i)
{
    int x;
    if (i > 0)
    {
        printf("Before %d\n", x); // UNDEFINED BEHAVIOUR
    }
    x = i;
    printf("After %d\n", x);
}

If you compile and run the above (with no optimisation), you'll probably find it prints sensible values but, each time you go round the loop, x is theoretically a completely new object, so the first printf accesses an uninitialised variable. This is undefined behaviour so the program may give you the value from the previous iteration because it is using the same storage or it may firebomb your house and sell your daughter into slavery.

Upvotes: 5

user2736738
user2736738

Reputation: 30926

This is an implementation specific detail.

For example, in code optimization stage it might detect those are not used. So no space will be allocated for them.

Even if some compiler has not that thing, then you can expect that there might be cases where two different variables spaces are not allocated.

For your information, the thing braces doesn't always mean it is different memory or stack space. It is a scope issue. And for the variable it might be the case that they are allocated in CPU register.

So you can't say anything in general. The thing you can say is they are of different scope.

Upvotes: 2

Kevin Boone
Kevin Boone

Reputation: 4307

I would expect that most compilers will use memory on the stack for variables of this type, if any memory is needed at all. In some cases a CPU register might be used for one or both the x's. Both will have their own storage, but it's compiler-dependent whether the lifetime of that storage is the same as the scope of the variables as declared in the source. So, for example, the memory used for the "inner" x might continue to be in use beyond the point at which that variable is out of scope -- this really depends on the compiler implementation.

Upvotes: 1

Related Questions