---

程序地址空间前景回顾

历史核心问题：

pid_t id = fork();

if(id == 0)

else if(id>0)

为什么一个id可以放两个值呢？之前没有仔细讲。

---

C语言空间布局图：

---

代码1

来看一段代码：

#include <stdio.h>
#include <stdlib.h>int main(){char *str = "hello linux";*str = 'H';printf("xxx=%s\n",getenv("xxx")); // 获取环境变量xxx的值return 0;
}

这段代码编译会报错。

因为"hello linux"储存在字符常量区，具有只读属性， *str = 'H';这个代码表面上我们是想要把第一个h换成H，但是因为只有只读属性，无法更改。

---

代码2

接下来写一段代码：

#include <stdio.h>
#include <stdlib.h>int g_val_1;//未初始化全局变量
int g_val_2 = 100;//已初始化全局变量int main(){printf("code addr:%p\n",main); // 打印main函数的地址，位于代码段const char* str="hello linux";printf("read only string addr:%p\n",str); // 打印字符串常量的地址，位于只读数据段printf("init global value affr:%p\n",&g_val_2); // 打印已初始化的全局变量地址，位于数据段printf("uninit global value affr:%p\n",&g_val_1); // 打印未初始化的全局变量地址，位于BSS段char *men = (char*)malloc(100);printf("head addr:%p\n",men); // 打印堆区地址printf("stack addr:%p\n",&str); // &str是指针变量本身的地址，而不是它指向的字符串的地址return 0;
}

运行结果：

可以看到，下方的始终要比上方的地址大一点。

---

代码3

我们还可以把代码再改一下：

#include <stdio.h>
#include <stdlib.h>int g_val_1;//未初始化全局变量
int g_val_2 = 100;//已初始化全局变量int main(){printf("code addr:%p\n",main); // 打印main函数的地址，位于代码段const char* str="hello linux";printf("read only string addr:%p\n",str); // 打印字符串常量的地址，位于只读数据段printf("init global value affr:%p\n",&g_val_2); // 打印已初始化的全局变量地址，位于数据段printf("uninit global value affr:%p\n",&g_val_1); // 打印未初始化的全局变量地址，位于BSS段char *men = (char*)malloc(100);printf("head addr:%p\n",men); // 打印堆区地址printf("stack addr:%p\n",&str); // &str是指针变量本身的地址，而不是它指向的字符串的地址printf("stack addr:%p\n",&men); // 打印men指针变量本身的地址,位于栈区 int a; // 定义3个局部变量,它们都位于栈区int b; // 栈区地址从高到低分配int c;printf("stack addr:%p\n",&a); // 打印局部变量的地址,位于栈区printf("stack addr:%p\n",&b); // 打印局部变量的地址,位于栈区printf("stack addr:%p\n",&c); // 打印局部变量的地址,位于栈区return 0;
}

运行结果：

为什么栈区地址看起来不规律，但实际上栈的增长方向是从高地址到低地址：

1. 不同类型变量的对齐要求不同
2. 编译器优化会重排变量位置
3. 指针变量（str和men）通常会放在一起
4. 整型变量（a,b,c）通常会放在一起

---

代码4

我们还可以把代码再改一下：

#include <stdio.h>
#include <stdlib.h>int g_val_1;//未初始化全局变量
int g_val_2 = 100;//已初始化全局变量int main(){printf("code addr:%p\n",main); // 打印main函数的地址，位于代码段const char* str="hello linux";printf("read only string addr:%p\n",str); // 打印字符串常量的地址，位于只读数据段printf("init global value affr:%p\n",&g_val_2); // 打印已初始化的全局变量地址，位于数据段printf("uninit global value affr:%p\n",&g_val_1); // 打印未初始化的全局变量地址，位于BSS段char *men = (char*)malloc(100);char *men1 = (char*)malloc(100);char *men2 = (char*)malloc(100);printf("head addr:%p\n",men); // 打印堆区地址printf("head addr:%p\n",men1); // 打印堆区地址printf("head addr:%p\n",men2); // 打印堆区地址printf("stack addr:%p\n",&str); // &str是指针变量本身的地址，而不是它指向的字符串的地址printf("stack addr:%p\n",&men); // 打印men指针变量本身的地址,位于栈区 int a; // 定义3个局部变量,它们都位于栈区int b; // 栈区地址从高到低分配int c;printf("stack addr:%p\n",&a); // 打印局部变量的地址,位于栈区printf("stack addr:%p\n",&b); // 打印局部变量的地址,位于栈区printf("stack addr:%p\n",&c); // 打印局部变量的地址,位于栈区return 0;
}

运行结果：

堆区地址上升。

---

代码5

验证一个语法问题：

为什么用static修饰的变量不会被释放呢？

我们把代码改一下：

#include <stdio.h>
#include <stdlib.h>int g_val_1;//未初始化全局变量
int g_val_2 = 100;//已初始化全局变量int main(){printf("code addr:%p\n",main); // 打印main函数的地址，位于代码段const char* str="hello linux";printf("read only string addr:%p\n",str); // 打印字符串常量的地址，位于只读数据段printf("init global value affr:%p\n",&g_val_2); // 打印已初始化的全局变量地址，位于数据段printf("uninit global value affr:%p\n",&g_val_1); // 打印未初始化的全局变量地址，位于BSS段char *men = (char*)malloc(100);char *men1 = (char*)malloc(100);char *men2 = (char*)malloc(100);printf("head addr:%p\n",men); // 打印堆区地址printf("head addr:%p\n",men1); // 打印堆区地址printf("head addr:%p\n",men2); // 打印堆区地址printf("stack addr:%p\n",&str); // &str是指针变量本身的地址，而不是它指向的字符串的地址printf("stack addr:%p\n",&men); // 打印men指针变量本身的地址,位于栈区 static int a; // 定义3个局部变量,它们都位于栈区int b; // 栈区地址从高到低分配int c;printf("a = stack addr:%p\n",&a); // 打印局部变量的地址,位于栈区printf("stack addr:%p\n",&b); // 打印局部变量的地址,位于栈区printf("stack addr:%p\n",&c); // 打印局部变量的地址,位于栈区return 0;
}

运行结果：

说明static修饰的局部变量，编译的时候就已经被编译到全局数据区了。

---

代码6

我们改一下代码：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>int g_val = 100;int main()
{pid_t id = fork();if(id == 0){//子进程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);}}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;
}

运行结果：

---

代码7

然后改一下代码：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>int g_val = 100;int main()
{pid_t id = fork();if(id == 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;printf("子进程change g-val : 100->200\n");cnt--;}}}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;
}

运行结果：

我们可以看到子进程改成了200，父进程没有变。

但是这不重要，重要的是他们两个不同的值，地址却是一样的。

匪夷所思！但是结论是这样的。

至少我们现在可以认为：如果变量的地址是物理地址，那么是不可能存在上述现象的。所以这个地址绝对不是物理地址。

我们一般叫这个为线性地址，或者虚拟地址。

我们平时写的C/C++，用的指针，指针里面存放的地址全都不是物理地址！