探秘内存黑匣子：程序地址空间的底层真相与趣味实践

#include <stdio.h>    
#include <stdlib.h>    

int g_val_1; // 一个没初始化的全局变量，就像一个空盒子
int g_val_2 = 100; // 初始化好的全局变量，里面装着数字100
int main(int argc, char* argv[], char* env[])    
{    
    printf("code addr：%p\n", main);// 打印main函数地址，看看代码区在哪
    const char *str = "Hello word";// 定义一个字符串常量，像一句固定的台词
    printf("read only string addr：%p\n", str);// 打印字符常量区地址    
    printf("init global value addr：%p\n", &g_val_2);// 已初始化全局变量地址    
    printf("uninit global value addr：%p\n", &g_val_1); // 未初始化全局变量地址    
    char* men1 = (char*)malloc(100);    
    printf("heap addr-men1：%p\n", men1);// 堆区地址，像一个动态仓库    
    printf("stack addr-str：%p\n", &str); // 栈区地址    
    static int a = 10;// 静态局部变量，有点特别哦    
    printf("static a add：%p\n", &a); // 静态局部变量地址    
    int i = 0;    
    for(; argv[i]; i++)    
        printf("argv[%d],addr：%p\n", i, argv[i]);// 打印命令行参数地址   
    for(i = 0; env[i]; i++)    
        printf("env[%d],addr：%p\n", i, env[i]);// 打印环境变量地址                                                                                                                                           
    return 0;    
}

code addr：0x555555554810
read only string addr：0x555555556014
init global value addr：0x555555556020
uninit global value addr：0x55555555601c
heap addr-men1：0x555555758780
stack addr-str：0x7ffc406769c8
static a add：0x555555556018
argv[0],addr：0x555555554770
env[0],addr：0x7ffc40676e78
env[1],addr：0x7ffc40676e88
env[2],addr：0x7ffc40676e98
... // 省略更多环境变量的输出

int main()    
{    
    int a;    
    int b;    
    int c;    
    int d;    
    printf("stack addr：%p\n", &a);    
    printf("stack addr：%p\n", &b);    
    printf("stack addr：%p\n", &c);    
    printf("stack addr：%p\n", &d);                                                                                                                                                                               
}    

stack addr：0x7ffd4612376c
stack addr：0x7ffd46123768
stack addr：0x7ffd46123764
stack addr：0x7ffd46123760

int main()    
{    
    char* mem1 = (char*)malloc(100);    
    char* mem2 = (char*)malloc(100);    
    char* mem3 = (char*)malloc(100);    
    char* mem4 = (char*)malloc(100);    
    printf("Heap addr：%p\n", mem1);    
    printf("Heap addr：%p\n", mem2);    
    printf("Heap addr：%p\n", mem3);    
    printf("Heap addr：%p\n", mem4);                                                                                                                                                                              
    return 0;    
}

Heap addr：0x555555758780
Heap addr：0x555555758800
Heap addr：0x555555758880
Heap addr：0x555555758900

int g_val_1; 
int g_val_2 = 100; 
int main()    
{    
    printf("code addr：%p\n", main);    
    const char *str = "Hello word";    
    printf("read only string addr：%p\n", str);    
    printf("init global value addr：%p\n", &g_val_2);    
    printf("uninit global value addr：%p\n", &g_val_1); 
    char* men1 = (char*)malloc(100);    
    printf("heap addr-men1：%p\n", men1);    
    printf("stack addr-str：%p\n", &str);    
    static int a = 10;                                                                                                                                                                     
    printf("static a add：%p\n", &a);    
    return 0;    
}

code addr：0x56205750d169
read only string addr：0x56205750d288
init global value addr：0x56205770e010
uninit global value addr：0x56205770e00c
heap addr-men1：0x562057b0f740
stack addr-str：0x7ffd78d26858
static a add：0x56205770e008

int g_val = 100;                                                                                                                                                                                                  
int main()
{
    pid_t pid = fork();

    if(pid == 0)
    {
        int cnt = 5;
        // 子进程的“表演时间”
        while(1)
        {
            printf("I am child, pid：%d, ppid：%d, g_val：%d, &g_val：%p\n", getpid(), getppid(), g_val, &g_val);
            sleep(1);
            if(cnt)
            {
                cnt--;
            }    
            else    
            {    
                g_val = 200;    
            }    
        }    
    }    
    else    
    {    
        // 父进程也来“凑热闹”
        while(1)    
        {    
            printf("I am parent, pid：%d, ppid：%d, g_val：%d, &g_val：%p\n", getpid(), getppid(), g_val, &g_val);    
            sleep(1);    
        }    
    }    
    return 0;    
}

I am parent, pid：12344, ppid：1000, g_val：100, &g_val：0x555555556020
I am child, pid：12345, ppid：12344, g_val：100, &g_val：0x555555556020
I am parent, pid：12344, ppid：1000, g_val：100, &g_val：0x555555556020
I am child, pid：12345, ppid：12344, g_val：100, &g_val：0x555555556020
I am parent, pid：12344, ppid：1000, g_val：100, &g_val：0x555555556020
I am child, pid：12345, ppid：12344, g_val：100, &g_val：0x555555556020
I am parent, pid：12344, ppid：1000, g_val：100, &g_val：0x555555556020
I am child, pid：12345, ppid：12344, g_val：100, &g_val：0x555555556020
I am parent, pid：12344, ppid：1000, g_val：100, &g_val：0x555555556020
I am child, pid：12345, ppid：12344, g_val：200, &g_val：0x555555556020
I am parent, pid：12344, ppid：1000, g_val：100, &g_val：0x555555556020
I am child, pid：12345, ppid：12344, g_val：200, &g_val：0x555555556020
... // 持续打印，父子进程g_val值不同

struct mm_struct
{
	unsigned long start_code;   // 代码段的起始地址
	unsigned long end_code;     // 代码段的结束地址
	unsigned long start_data;   // 数据段的起始地址
	unsigned long end_data;     // 数据段的结束地址
	unsigned long start_brk;    // 堆的起始地址（用于动态分配）
	unsigned long brk;          // 堆的当前结束地址
	unsigned long start_stack;  // 栈的起始地址（通常是高地址）
	// 其他字段...
};

#include <stdio.h>    
      
int main()    
{    
    char* str = "Hello World";    
    *str = 'B';  // 试图修改只读内存                                                  
    return 0;    
}