If we start at some address, how can we determine the addresses that variables occupy throughout a program? [closed]

Answer 1

On x86-16 bit:

int a;      // two bytes
struct{
    char b;    // One byte. 
    struct{     // Struct itself is aligned to the size of pointer
        short *c[20];    // pointers may be 2 or 4 bytes depending on compile mode. 
        char d;          // one byte
    }e;
}f;
double g;     // 8 bytes aligned to 8 bytes. 
char *h;    // 2 or 4 bytes. 

On x86-32 bit:

int a;    // four bytes. 
struct{
    char b;   // one byte. 
    struct{   // struct padding to size of pointer. 
        short *c[20];  // pointers are 4 bytes. 
        char d;        // one byte. 
    }e;
}f;
double g;     // 8 bytes, aligned to 8 bytes. 
char *h;      // 4 bytes. 

On x86-64:

int a;      // 4 bytes. 
struct{
    char b;  // One byte.
    struct{   // struct aligned to size of pointer
        short *c[20];   // Pointers are 4 or 8 bytes (typically 8)
        char d;   // One byte.
    }e;
}f;
double g;    // 8 bytes. Aligned to 8 bytes. 
char *h;     // 4 or 8 byte pointer, aligned to size of pointer. 

In some other architecture, this is perfectly valid:

int a;      // 8 bytes
struct{
    char b;   // 4 bytes. 
    struct{   // Struct is not aligned to anything.
        short *c[20];  // Pointers are 8 bytes. 
        char d;       // 4 bytes
    }e;    
}f;
double g;  // 12 bytes, aligned to 4 bytes.  
char *h;   // pointers are 8 bytes. 

I'll let you do the math for each example to calculate what the actual address is. But like everyone else has said, the layout is entirely up to the compiler, and is not possible to determine without understanding the rules of the particular compiler/architecture of the processor.

Answer 2

There's no real rule. It's up to the compiler. About all you're guaranteed is that the address of b is below the address of e, and the address of c is below the address of d. And that the addresses of the first elements of each struct are the same as the address of the struct. On the other hand, there are no guarantees whatever for the elements outside of any struct. The compiler may allocate a, f, g and h in any way it pleases.

Answer 3

Each pointer takes 32 or 64 bits, depending on your platform. An array of 20 elements takes 20 times the size of one such element, and so on.

The extra spaces are taken for alignment reasons. Memories usually can read/write several bytes at the same time, as long as they are in the same word or doubleword. Bytes 100-103 form a doubleword. The next one starts at 104... All this is completely platform-dependant. On some platforms it's even illegal to read a word in a non-word-aligned address.