What happens when a variable goes out of scope?

by

The actual behavior of your code sample is determined by two primary factors: 1) the behavior is undefined by the language, 2) an optimizing compiler will generate machine code that does not physically match your C code.

For example, despite the fact that the behavior is undefined, GCC can (and will) easily optimize your code to a mere 

printf("ptr = %d\n", 17);

which means that the output you see has very little to do with what happens to any variables in your code.

If you want the behavior of your code to better reflect what happens physically, you should declare your pointers volatile. The behavior will still be undefined, but at least it will restrict some optimizations.

Now, as to what happens to local variables when they go out of scope. Nothing physical happens. A typical implementation will allocate enough space in the program stack to store all variables at the deepest level of block nesting in the current function. This space is typically allocated in the stack in one shot at the function startup and released back at the function exit.

That means that the memory formerly occupied by tmp continues to remain reserved in the stack until the function exits. That also means that the same stack space can (and will) be reused by different variables having approximately the same level of “locality depth” in sibling blocks. The space will hold the value of the last variable until some other variable declared in some sibling block variable overrides it. In your example nobody overrides the space formerly occupied by tmp, so you will typically see the value 17 survive intact in that memory.

However, if you do this

int main(void) {
  volatile int *ptr;
  volatile int *ptrd;

  { // Block
    int tmp = 17;
    ptr = &tmp; // Just to see if the memory is cleared
  }

  { // Sibling block
    int d = 5;
    ptrd = &d;
  }

  printf("ptr = %d %d\n", *ptr, *ptrd);
  printf("%p %p\n", ptr, ptrd);
}

you will see that the space formerly occupied by tmp has been reused for d and its former value has been overriden. The second printf will typically output the same pointer value for both pointers.

More Related Contents:

  1. How can I get the size of an array from a pointer in C?
  2. Difference between static memory allocation and dynamic memory allocation
  3. Where in memory are my variables stored in C?
  4. Why is malloc not “using up” the memory on my computer?
  5. What does this GCC error “… relocation truncated to fit…” mean?
  6. Create a wrapper function for malloc and free in C
  7. Maximum memory which malloc can allocate
  8. What does the brk() system call do?
  9. Where are constant variables stored in C?
  10. How do you store an arbitrarily large integer value in memory?
  11. Should I free char* initialized using string-literals?
  12. How can I create a dynamically sized array of structs?
  13. Alloca implementation
  14. malloc implementation?
  15. can size of array be determined at run time in c?
  16. Why do I get different results when I dereference a pointer after freeing it?
  17. Is it ok to use “classic” malloc()/free() in Objective-C/iPhone apps?
  18. Using realloc to shrink the allocated memory
  19. Memory usage of current process in C
  20. Determining Stack Space with Visual Studio
  21. Why / when to use `intptr_t` for type-casting in C?
  22. Force free() to return malloc memory back to OS
  23. Size of stack and heap memory [duplicate]
  24. C: pointer to array of pointers to structures (allocation/deallocation issues)
  25. malloc for struct and pointer in C
  26. Is freeing allocated memory needed when exiting a program in C
  27. dynamic memory for 2D char array
  28. Is free() zeroing out memory?
  29. Struct varies in memory size?
  30. Is it safe to use realloc?

Leave a Comment