[Linux 进程(四)] 再谈环境变量，程序地址空间初识

1、前言

上一篇我们讲了环境变量，如果有不明白的先读一下上一篇文章：环境变量讲解
本篇文章我们继续完善环境变量这章剩下的内容，以及main函数第三个参数的详解，进程地址空间的初始。

2、环境变量

2.1 main函数第三个参数 – 环境参数表

看完上一篇文章的同学，肯定知道了如何查看环境变量，命令行输入 env：
我们查看一下：

我们main函数的参数列表中，第三个就是环境变量表，没错它里面就记录着这些环境变量。
它与第二个参数一样，都是char类型的指针数组。我们写一段代码，打印一下环境变量表中的内容：

#include <stdio.h>

int main(int argc, char* argv[], char* env[])
{
	int i = 0;
    for( ; env[i]; i++)
    {
        printf("env[i]: %s\n", i, env[i]);
    }
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

我们发现main函数的第三个参数，环境参数表跟我们env所查出来的内容是一模一样的。
这是因为我们程序在运行时，环境变量是系统给传的。
问题：
那这个给程序传环境变量的系统是谁？
在学习fork的时候，我们知道fork()函数是可以创建子进程的。同时我们也知道命令行启动的进程都是shell/bash的子进程，子进程的命令行参数和环境变量，是父进程bash给传递的！
问题：
那父进程bash的环境变量信息又是从哪里来的？
我们在上一篇中讲到，PATH内容修改后，下一次启动Xshell时，PATH内容又自动恢复了。这其实是我们直接更改了bash进程内部的环境变量信息！
每一次重新登录，都会给我们形成新的bash解释器并且新的bash解释器自动从 哪里 读取自己的环境变量表信息！
虽然我们现在还不知道父进程环境变量哪里来的，但是环境变量存在哪我就直接说了：环境变量信息是以脚本配置文件的形式存在的！
在登录目录下有一个.bash_profile脚本文件，每一次登录的时候，bash进程都会读取 .bash_profile配置文件中的内容，为我们bash形成一张环境变量表信息！

2.2 本地环境变量和env中的环境变量

我们可以在bash中直接定义环境变量：环境变量名 = 内容
我们来试一下：

用户定义的环境变量是本地的，env是查看不了本地环境变量的。

如果我们想要把我们自己定义的环境变量，导出到env所能查看到的环境变量中，我们可以使用以下命令：

export 环境变量名
1

还可以直接使用export定义环境变量：

当我们把自己定义的环境变量放入了bash的环境变量后，我们在main函数所打印的环境变量中能不能找到呢，我们试一下：

我们在命令行中输入的命令都是bash的子进程，这就验证了子进程的环境变量是由父进程给传递的。

2.3 配置文件与环境变量的全局性

问题：
我们要是重新登录Xshell的话，我们刚导出的环境变量还在吗？
在不在我们测试一下就出来了：

明显是不在的，我们刚才导出是直接给bash进程的内部导出了。我们重新启动后 .bash_profile脚本文件会重新执行，bash进程内部的环境变量会重新读取并形成一份新的环境变量表。
如果我们想要每次登录后，bash的环境变量表都有我们自己添加的环境变量，我们就需要在 .bash_profile脚本文件中添加，此后再登录后bash的环境变量表中就有了添加的环境变量。


我们再介绍一个获取环境变量的系统调用函数，const char ** environ

我们发现environ的类型是一个二级指针，这里不卖关子了，它其实指的是环境变量表首元素：

我们写一段代码将其内容打印出来：

#include <stdio.h>
#include <unistd.h>

int main()
{
	extern char** environ;
    int i = 0;
    for(i = 0; environ[i]; i++)
    {
        printf("environ[%d]: %s\n", i, environ[i]);
    }
    
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

问题： 大家有没有想过，如果我们本地环境变量，子进程会将我们添加的本地环境变量也继承下来吗？
我们做一下实验：

显然是没有的（这里细心的人会发现echo为什么就继承下来了，其实echo不是子进程，别急下一个话题我们就会讲到）。如果我们将本地变量导出到系统环境变量中，子进程就会将其继承下来。
总结：
1、迄今为止我们学到了三种获取环境变量的方式：

• getenv();
• main函数传参方式；
• extern char** environ;

2、bash再去创建子进程时，bash会给子进程传递一份同样的环境变量，子进程再创建子进程天然的就继承了父进程的环境变量表，也就间接获取了bash所传递的环境变量，所以系统环境变量具有全局属性！

3、本地环境变量 vs 系统环境变量

• 本地环境变量只在bash进程内部有效，不会被子进程继承下去；
• 系统环境变量通过让所有子进程继承的方式，实现自身的全局性！

2.4 内建命令与常规命令

通过上一篇的学习，我们知道了，bash自己的指令可以直接使用，不用加 ./，因为这些指令在系统默认路径PATH下，现在我们将PATH置空，这些指令就运行不了了！

我们发现，有些指令确实不能运行了，但是有些指令仍然可以运行。这是为什么呢？
Linux下命令分为两类：

• 常规命令：shell通过fork创建子进程，让子进程执行的；
• 内建命令：shell命令行的一个函数。

原来pwd，echo都是内建命令。
那为什么内建命令就直接能读取环境变量呢？
内建命令是shell内部的一个函数，父进程内部执行，它是可以直接看到父进程内部的，当然可以直接读取shell内部定义的本地变量！

2.5 环境变量相关的命令

1. echo: 显示某个环境变量值
2. export: 导出一个新的环境变量
3. env: 显示所有环境变量
4. unset: 清除环境变量
5. set: 显示本地定义的shell变量和环境变量
   

3、程序地址空间

C/C++程序员认为，程序内存分布是这样子的：

我们写一段代码验证一下：

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

int uninit_global;
int init_global = 0;
int main(int argc, char* argv[], char* env[])
{
    printf("code address: %p\n", main); // 代码区
    const char* str = "Hello Linux!\n";
    printf("read only char address: %p\n", str); // 字符常量区
    printf("init global value address: %p\n", &init_global);
    printf("uninit global value address: %p\n", &uninit_global);

    char* heap1 = (char*)malloc(sizeof(char)*100);
    char* heap2 = (char*)malloc(sizeof(char)*100);
    char* heap3 = (char*)malloc(sizeof(char)*100);
    char* heap4 = (char*)malloc(sizeof(char)*100);
    static int a = 0;
    printf("heap1 address: %p\n", heap1);                                                                                         
    printf("heap2 address: %p\n", heap2);
    printf("heap3 address: %p\n", heap3);
    printf("heap4 address: %p\n", heap4);

    printf("stack address: %p\n", &str);
    printf("stack address: %p\n", &heap1);
    printf("stack address: %p\n", &heap2);
    printf("stack address: %p\n", &heap3);
    printf("stack address: %p\n", &heap4);
	printf("a address: %p\n," &a);

    int i = 0;
    for(i = 0; i < argc; i++)
    {
        printf("argv[%d]: %p\n", i, argv[i]);
    }

    for(i = 0; env[i]; i++)
    {
        printf("env[%d]: %p\n", i, env[i]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

我们在这里就能看出来：
1、堆上的地址内存的使用是不断增大；
2、栈上的地址内存的使用是不断减小的，但是在我们c/c++中，定义数组、结构体或者整型，它们的地址是向上增长的。比如，开辟一个十个元素的整型数组，一次整体开出来，首元素地址在最低，因此遍历时是++操作。
3、static修饰的静态成员变量，其实就是全局变量，他就放在已初始化全局变量区，所以它在全局就一份。
4、栈区之上先是命令行参数，再是环境变量，不断向上增上的。