Is memory allocated when the variable is not used in c

Question

#include<stdio.h>
int main()
{
    int a,b;
    float e;
    char f;
    printf("int &a = %u\n",&a);
    printf("int &b = %u\n",&b);
    printf("float &e = %u\n",&e);
    printf("char &f = %u\n",&f);
}

The Output is

int &a = 2293324
int &b = 2293320
float &e = 2293316
char &f = 2293315

But when i use this code and replace the printf for float--

#include<stdio.h>
int main()
{
    int a,b;
    float e;
    char f;
    printf("int &a = %u\n",&a);
    printf("int &b = %u\n",&b);
    printf("char &f = %u\n",&f);
}

Then the Output is

int &a = 2293324
int &b = 2293320
char &f = 2293319

here address is not provided to float, but it is declared on top. My questions are

1. Is memory not allocated to variables not used in program?
2. Why addresses allocated in decreasing order. ex- it's going from 2293324 to 2293320?

Answer 1

1) Is memory not allocated to variables not used in program?

Yes that can happen, the compiler is allowed to optimize it out.

2) Why addresses allocated in decreasing order. ex- it's going from 2293324 to 2293320?

That is usual for most local storage implementations, that they use the CPU supported stack pointer going from stack top to stack bottom. All those local variables will be allocated at the stack most probably.

Answer 2

1) Is memory not allocated to variables not used in program?

It's an allowed optimization; if an unused variable doesn't affect the program's observable behavior, a compiler may just discard it completely. Note that most modern compilers will warn you about unused variables (so you can either remove them from the code or do something with them).

2) Why addresses allocated in decreasing order. ex- it's going from 2293324 to 2293320?

The compiler is not required to allocate storage for separate objects in any particular order, so don't assume that your variables will be allocated in the order they were declared. Also, remember that on x86 and some other systems, the stack grows "downwards" towards decreasing addresses. Remember the top of any stack is simply the location where something was most recently pushed - it has nothing to do with relative address values.

Answer 3

While not specifically required by the standard, local variables are universally located on the program stack.

When you enter a function, one of the first thing done is to decrement the stack pointer to provide space for the local variables.

  SUBL #SOMETHING, SP

Where SOMETHING is the amount of space required and SP is the stack pointer register.. In your first example, SOMETHING is probably 13. Then the address of:

  f is 0(SP)
  e is 1(sp)
  b is 5(sp)
  a is 9(sp)

I am assuming your compiler did not align the stack pointer. Often they do giving something more like:

  f is 3(SP)
  e is 4(sp)
  b is 8(sp)
  a is 12(sp)

And SOMETHING would be rounded up to 16 on a 32-bit system.

You might want to generate an assembly listing using your compiler to see what is going on underneath.

Is memory not allocated to variables not used in program?

Note that for local variable memory is not really allocated. A variable is temporarily bound to a location on the program stack (stack is not required by the standard but is how it is done in most cases). That is why the variable's initial value is undefined. It could have been bound to something else previously.

The compiler does not need to reserve space for variables that are not used. They can be optimized away. Usually, there are compiler settings to instruct not to do this for debugging.

Why addresses allocated in decreasing order. ex- it's going from 2293324 to 2293320?

Program stacks generally grow downward. Starting ye olde days, the program would be at the bottom of the address space, the heap above that and the stack at the opposite end.

The heap would grow towards higher addresses. The stack would grow towards the heap (lower addresses).

While the address spaces can be more complicated than that these days, the downward growth of stacks has stayed.

There is no particular requirement that the compiler map the variables to the stack in descending order but there's a 50/50 chance it will do it that way.