Windows（VS2010）上的实际C ++程序内存布局

Question

Lately I have been reading some articles about C++ memory layout and simplifiying I understand there is 3 main blocks:

• fixed memory: code, global and static variables
• stack memory: local values and function values
• heap memory: memory managed by the user (malloc/free new/delete)

According to the post I read I assume a big block of memory is allocated and splited on the above parts.

To check this I have created a simple program:

#include <stdio.h>

int g_loopCount;
static int gs_one = 1;

int getLifeResult(int a)
{
    printf("&a     %d\t\t%p\n", g_loopCount, &a);
    if(++g_loopCount < 4)
    {
        getLifeResult(a);
    }
    else
    {
        return g_loopCount * 10 + a;
    }
}

int main()
{
    //fixed
    printf("-fixed-\n");
    printf("&gs_one\t\t\t%p\n", &gs_one);
    g_loopCount = 0;
    printf("&g_loopCount\t\t%p\n\n", &g_loopCount);

    int* lifeResult = new int(0);
    int* lifeResultCopy = new int(0);

    //stack
    printf("-stack-\n");
    printf("&lifeResult\t\t%p\n", &lifeResult);
    printf("&lifeResultC\t\t%p\n", &lifeResultCopy);
    *lifeResult = getLifeResult(2);
    *lifeResultCopy = *lifeResult;
    printf("\n");

    //heap
    printf("-heap-\n");
    printf("lifeResult\t\t%p\n", lifeResult);
    printf("lifeResultC\t\t%p\n\n", lifeResultCopy);

    return *lifeResult;
}

However even when the memory adress are consistent in between the mentioned memory blocks. The order of these main blocks changes form one execution to other.

                 run 0      run 1           run 2
-fixed-
&gs_one          00E37000   00A37000    00047000
&g_loopCount     00E37140   00A37140    00047140

-stack-
&lifeResult      0037FD6C   0030FD44    003EF784
&lifeResultC     0037FD60   0030FD38    003EF778
&a     0         0037FC70   0030FC48    003EF688
&a     1         0037FB98   0030FB70    003EF5B0
&a     2         0037FAC0   0030FA98    003EF4D8
&a     3         0037F9E8   0030F9C0    003EF400

-heap-
lifeResult       00684670   00184670    00724670
lifeResultC      006846B0   001846B0    007246B0

Is that normal? What the location of these blocks depends on: OS, compiler? Does it happen to every operating systems? Can anyone explain me a little bit more about this mechanism?

Thank you!

Answer 1

The OS rules everything.

First off, modern code is relocatable. Pretty much an operating system, particularly Windows, will figure out where your program runs at dynamically when it is loaded. This is pretty important in making DLLs play together but it can happen at any time.

Check this out: http://en.wikipedia.org/wiki/Portable_Executable

Also, the amount of stack your program can consume can change.

Answer 2

You can disable this at least for the base address, by going to your project settings and go to:

Project|Properties|Linker|Advanced|Randomize Base Address

Set this entry to "No (/DYNAMICBASE:NO)"

You can also use a fixed base address (/FIXED /BASE)