文章目录
- 前言
- [一. 命令行参数](#一. 命令行参数)
- [二. 环境变量](#二. 环境变量)
-
- [2.1 查看环境变量](#2.1 查看环境变量)
- [2.2 设置环境变量](#2.2 设置环境变量)
- [2.3 常见的环境变量](#2.3 常见的环境变量)
- [2.4 获取环境变量](#2.4 获取环境变量)
- [2.5 理解环境变量](#2.5 理解环境变量)
- [三. 程序地址空间](#三. 程序地址空间)
-
- [3.1 虚拟地址](#3.1 虚拟地址)
- [3.2 进程地址空间](#3.2 进程地址空间)
- [3.3 虚拟内存管理](#3.3 虚拟内存管理)
- [3.4 为什么要有虚拟地址空间](#3.4 为什么要有虚拟地址空间)
- 最后
前言
在上一篇文章中，我们详细介绍了进程、进程状态、进程优先级和进程切换的内容，内容还是挺多的，希望大家可以多去练习熟悉一下，那么本篇文章将带大家详细讲解命令行参数、环境变量和进程地址空间的内容，接下来一起看看吧！
一. 命令行参数
我们输入的指令本质上也是一个程序，那么我们给指令带选项，是如何实现的呢？
我们都知道main函数是程序的入口；但是操作系统在执行程序之前，会先执行一个入口函数(_start)，然后由这个入口函数去找到并调用我们的main函数。
那main函数到底有没有参数？答案是有的。
c
#include <stdio.h>
int main(int argc, char* argv[])
{
for(int i=0;i<argc;i++)
{
printf("argv[%d]: %s\n", i, argv[i]);
}
return 0;
} 
argc为指针数组argv的大小（长度）
./code类似于指令；-a -b -c类似于指令的选项
main函数的参数都有哪些内容呢？
argc：命令行参数的个数
argv：命令行参数的内容（char*类型的数组，最后以NULL结尾）
env：环境变量表（在后面详细讲解）。
我们在命令行输入的内容是如何转化成argv表，并传递给main函数的呢？
我们的命令行解释器
bash对这些内容进行拆分（以空格进行拆分），然后形成命令行参数表（argv）和参数的个数（argc）。然后再通过调用等一系列操作（
bash创建子进程，通过execve系统调用）将参数传递给main函数。
二. 环境变量
- 环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数
- 如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。
- 环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性
为什么我们执行的自己的程序就要带路径，而使用指令就不用带路径？
我们想要运行一个程序，首先要先找到这个程序（让
bash去找），bash根据环境变量去指定路径下找，指定路径为/usr/bin。我们使用的指令程序都在/usr/bin目录下，而我们的程序不在/usr/bin目录下，所以指令程序不用带路径就可以找到，自己写的程序就需要带路径才能找到。
2.1 查看环境变量
env：显示所有环境变量echo $环境变量名：显示某个环境变量值
2.2 设置环境变量
export
export新增环境变量
powershell
export name=val
export除了可以新增一个环境变量，还可以使用它来修改一个已经存在的环境变量的值。
unset
unset：清除环境变量
powershell
unset name
2.3 常见的环境变量
PATH
PATH: 指定命令的搜索路径
我们执行一条指令不带路径的情况下，命令行解释器bash就会根据PATH，依次去找指定路径下的程序来执行。我们常用到的ls、pwd等指令都在/usr/bin/目录下。
如果我们想要执行我们自己的程序，可以添加当前路径到环境变量PATH中：
这样就能执行自己的程序了
注意 ：这个只是临时添加 ，如果重新打开XShell，PATH又是之前的默认值了。
HOME
还存在一个环境变量HOME；当我们执行cd ~时，命令行解释器bash就会在环境变量表中查找HOME，然后进入到HOME家目录（工作目录）中。
注意 ：不同用户的家目录（工作目录）不相同。
SHELL
SHELL环境变量，它表示当前的shell，也就是当前使用的命令行解释器；
一般情况下是/bin/bash。
更多环境变量
HOSTNAME：表示当前系统的主机名
HISTSIZE：表示bash记录历史指令的个数
SSH_TTY：表示当前通过SSH会话链接终端设备的路径
PWD：表示当前路径
USER：表示当前用户名
LOGNAME：表示当前用户的登录名，可以理解为和USER一样
_：表示上次路径
2.4 获取环境变量
main函数参数
除了可以使用env和echo $查看环境变量完，还可以通过代码的形式来查看环境变量，我们之前说过main函数参数存在三个参数，第三个参数就是用来接收环境变量的。
c
#include <stdio.h>
int main(int argc, char *argv[], char *env[])
{
int i = 0;
for(; env[i]; i++){
printf("%s\n", env[i]);
}
return 0;
}
系统调用
我们还可以通过系统调用来在代码中获取环境变量的值。
getenv
c
#include<stdio.h>
#include<stdlib.h>
int main()
{
printf("%s\n",getenv("PATH"));
return 0;
}
通过第三方变量environ获取
libc中定义的全局变量environ指向环境变量表，environ没有包含在任何头文件中，所以在使用时 要用extern声明。
c
#include <stdio.h>
int main(int argc, char *argv[])
{
extern char **environ;
int i = 0;
for(; environ[i]; i++){
printf("%s\n", environ[i]);
}
return 0;
}
2.5 理解环境变量
疑问：环境变量最开始存储在哪里？
在系统的配置文件中
特性 ：环境变量通常具有全局属性 ，可以被子进程继承下去。
我们先导出一个环境变量MYENV
然后再写个程序，看看是否能查看环境变量MYENV
c
#include <stdio.h>
#include <stdlib.h>
int main()
{
char *env = getenv("MYENV");
if(env){
printf("%s\n", env);
}
return 0;
}
答案是可以查看到，所以环境变量可以被子进程继承下去。
本地变量
在操作系统中除了环境变量之外，还存在着本地变量，就比如我们在命令行直接输入i=1，我们可以使用echo $i来查看变量i的值，但使用env查看环境变量时是查看不到i的。
为什么要存在本地变量？
在 Linux 中存在本地变量主要有以下几个重要原因：
- 数据隔离与保护：本地变量只能在定义它们的当前 Shell 会话或脚本中使用，其他 Shell 会话或脚本无法直接访问。这样可以避免不同部分之间的变量冲突和数据意外修改，确保数据的安全性和独立性。
- 临时存储：本地变量非常适合用于在脚本或命令执行过程中临时存储数据。它们可以帮助在脚本的不同步骤之间传递信息，而无需将数据写入文件或影响全局环境。
- 提高脚本的可读性和可维护性：通过使用本地变量，可以使脚本中的数据操作更加清晰明了。变量的作用域被限制在特定的代码块或函数中，使得代码更易于理解和维护。
- 避免命名冲突：在大型脚本或复杂的 Shell 环境中，可能会有很多变量。本地变量的存在可以减少因变量名相同而导致的问题，确保每个变量在其特定的范围内发挥作用。
- 函数内部的局部作用：在函数中定义的本地变量只在该函数内部有效。这对于编写模块化和可重用的函数非常重要，因为函数可以拥有自己的私有变量，而不会干扰其他函数或全局环境。
- 节省资源：本地变量只在需要时创建和存在，当它们超出作用域时会被自动释放。这有助于节省系统资源，特别是在处理大量数据或长时间运行的脚本时。
- 增强脚本的灵活性：本地变量可以根据具体情况进行动态设置和调整，使脚本能够适应不同的运行条件和需求。
- 符合编程原则：本地变量的使用符合软件工程中的一些基本原则，如封装和信息隐藏。它们有助于将代码组织成更易于管理和理解的模块。
综上所述，本地变量在 Linux 中扮演着重要的角色，它们为 Shell 编程提供了一种有效的方式来管理和操作数据，同时保证了数据的安全性和代码的可维护性。
内建命令
在修改PATH时，一部分指令不能执行了，但是一部分指令是可以执行的，这是为什么呢？
这是因为有些指令是bash进程创建子进程去调用执行的，这些指令是普通命令；有些指令是bash自己去通过函数调用或者系统调用去完成的，而这些指令就是内建命令。
在 Linux 中，内建命令（built-in command） 是指由 Shell 本身实现并直接执行 的命令，不需要启动外部程序 。这些命令是 Shell 的一部分，通常用于执行一些基础、高频、需要访问 Shell 内部状态的操作。
✅ 为什么要有内建命令？
| 原因 | 说明 |
|---|---|
| 性能更高 | 不需要创建新进程（fork/exec），直接在 Shell 内部执行，速度更快。 |
| 可以修改 Shell 状态 | 比如修改当前目录、设置变量、改变环境等，外部命令做不到。 |
| 脚本更轻量 | 避免依赖外部程序，提升脚本的可移植性和兼容性。 |
| 安全性 | 某些命令（如 cd、exit）必须由 Shell 自己处理，外部命令无法实现。 |
🔧 常见的内建命令（以 Bash 为例）
| 命令 | 功能 |
|---|---|
cd |
改变当前目录（必须是内建，因为外部程序无法改 Shell 的 cwd） |
echo |
输出文本（有内建版本，也有外部版本 /bin/echo） |
export |
设置环境变量 |
read |
从标准输入读取变量 |
set / unset |
设置或取消 Shell 变量/选项 |
exit |
退出 Shell |
source 或 . |
在当前 Shell 中执行脚本（不启动子 Shell） |
alias / unalias |
设置/取消命令别名 |
history |
查看命令历史 |
type |
判断命令是内建、外部还是别名 |
pwd |
显示当前目录（有内建版本） |
⚠️ 注意
- 内建命令 没有独立可执行文件 ，所以
which cd会找不到。 - 有些命令既有内建版本，也有外部版本（如
echo、pwd、test），优先使用内建版本。 - 不同 Shell（如
bash、zsh、dash）内建命令可能略有不同。
✅ 总结一句话
内建命令是 Shell 的"自带工具箱"，它们让 Shell 能快速、安全、直接地处理日常任务，而不需要依赖外部程序。
三. 程序地址空间
可以先对其进行各区域分布验证：
c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int g_unval;
int g_val = 100;
int main(int argc, char *argv[], char *env[])
{
const char *str = "helloworld";
printf("code addr: %p\n", main);
printf("init global addr: %p\n", &g_val);
printf("uninit global addr: %p\n", &g_unval);
static int test = 10;
char *heap_mem = (char*)malloc(10);
char *heap_mem1 = (char*)malloc(10);
char *heap_mem2 = (char*)malloc(10);
char *heap_mem3 = (char*)malloc(10);
printf("heap addr: %p\n", heap_mem); //heap_mem(0), &heap_mem(1)
printf("heap addr: %p\n", heap_mem1); //heap_mem(0), &heap_mem(1)
printf("heap addr: %p\n", heap_mem2); //heap_mem(0), &heap_mem(1)
printf("heap addr: %p\n", heap_mem3); //heap_mem(0), &heap_mem(1)
printf("test static addr: %p\n", &test); //heap_mem(0), &heap_mem(1)
printf("stack addr: %p\n", &heap_mem); //heap_mem(0), &heap_mem(1)
printf("stack addr: %p\n", &heap_mem1); //heap_mem(0), &heap_mem(1)
printf("stack addr: %p\n", &heap_mem2); //heap_mem(0), &heap_mem(1)
printf("stack addr: %p\n", &heap_mem3); //heap_mem(0), &heap_mem(1)
printf("read only string addr: %p\n", str);
for(int i = 0 ;i < argc; i++)
{
printf("argv[%d]: %p\n", i, argv[i]);
}
for(int i = 0; env[i]; i++)
{
printf("env[%d]: %p\n", i, env[i]);
}
return 0;
}
3.1 虚拟地址
c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
int g_val = 0;
int main()
{
pid_t id = fork();
if(id < 0){
perror("fork");
return 0;
}
else if(id == 0){ // child
g_val=100;
printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
}
else{ //parent
sleep(3);
printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
}
sleep(1);
return 0;
}
我们发现，父子进程输出的地址是一样的，但是变量内容不一样！
所以可以得出以下结论：
- 变量内容不一样，所以父子进程输出的变量绝对不是同一个变量
- 但地址值是一样的，说明该地址绝对不是物理地址
- 在Linux地址下，这种地址叫做虚拟地址
- 我们在用C/C++语言时多看到的地址，全部都是虚拟地址！物理地址是用户一概看不到的，由操作系统统一管理
操作系统负责将虚拟地址转化成物理地址
3.2 进程地址空间
进程地址空间就是操作系统为每一个进程分配的一个虚拟内存视图，它让每一个进程都以为自己独占了整个计算机的内存资源。
- 一个进程，一个进程地址空间
- 一个进程，一套页表
页表是什么？
页表是操作系统内核维护的核心映射表，作用是建立 "虚拟地址" 与 "物理地址" 的对应关系，是连接虚拟地址空间和物理内存的 "桥梁"。
什么是写时拷贝？
父进程创建子进程时，子进程会拷贝父进程的
task_struct，同时会将父进程的进程地址空间、虚拟地址空间连同页表 进行浅拷贝 ，这样父子进程就共有代码和数据了。但是当子进程想要修改数据时，就会触发写时拷贝（触发机制：当子进程拷贝父进程的虚拟地址空间和页表时，操作系统会将变量改为只读，如果试图修改变量的值，就会以报错的形式交给操作系统，操作系统会再开辟一个空间拷贝该变量的值，子进程页表中的该变量的虚拟地址映射的物理地址就会发生改变），这样父子进程的变量其实是两个不同的变量，虽然虚拟地址还是一样的，但是物理地址不一样了。
3.3 虚拟内存管理
描述Linux下进程的地址空间的所有的信息的结构体是 mm_struct （内存描述符）。每个进程只有一个mm_struct 结构，在每个进程的 task_struct 结构中，有一个指向该进程的mm_struct结构体指针。
c
struct task_struct
{
/*...*/
struct mm_struct* mm; //对于普通的用户进程来说该字段指向他的虚拟地址空间的用户空间部分，对于内核线程来说这部分为NULL。
struct mm_struct* active_mm; // 该字段是内核线程使用的。当
//该进程是内核线程时，它的mm字段为NULL，表⽰没有内存地址空间，可也并不是真正的没有，这是因
//为所有进程关于内核的映射都是⼀样的，内核线程可以使用任意进程的地址空间。
/*...*/
};可以说， mm_struct 结构是对整个用户空间的描述。每一个进程都会有自己独立的 mm_struct ，这样每一个进程都会有自己独立的地址空间才能互不干扰。先来看看由 task_struct 到 mm_struct ，进程的地址空间的分布情况：
定位 mm_struct 文件所在位置和 task_struct 所在路径是一样的，不过他们所在文件是不一样的， mm_struct 所在的文件是 mm_types.h
c
struct mm_struct
{
/*...*/
struct vm_area_struct* mmap; /* 指向虚拟区间(VMA)链表 */
struct rb_root mm_rb; /* red_black树 */
unsigned long task_size; /*具有该结构体的进程的虚拟地址空间的大⼩*/
/*...*/
// 代码段、数据段、堆栈段、参数段及环境段的起始和结束地址。
unsigned long start_code, end_code, start_data, end_data;
unsigned long start_brk, brk, start_stack;
unsigned long arg_start, arg_end, env_start, env_end;
/*...*/
}那既然每一个进程都会有自己独立的 mm_struct ，操作系统肯定是要将这么多进程的 mm_struct 组织起来的！虚拟空间的组织方式有两种：
- 当虚拟区较少时采取单链表，由mmap指针指向这个链表；
- 当虚拟区间多时采取红黑树进行管理，由mm_rb指向这棵树。
linux内核使用 vm_area_struct 结构来表示一个独立的虚拟内存区域(VMA)，由于每个不同质的虚拟内存区域功能和内部机制都不同，因此一个进程使用多个vm_area_struct 结构来分别表示不同类型的虚拟内存区域。上面提到的两种组织方式使用的就是vm_area_struct结构来连接各个VMA，方便进程快速访问。
c
struct vm_area_struct {
unsigned long vm_start; //虚存区起始
unsigned long vm_end; //虚存区结束
struct vm_area_struct* vm_next, * vm_prev; //前后指针
struct rb_node vm_rb; //红⿊树中的位置
unsigned long rb_subtree_gap;
struct mm_struct* vm_mm; //所属的 mm_struct
pgprot_t vm_page_prot;
unsigned long vm_flags; //标志位
struct {
struct rb_node rb;
unsigned long rb_subtree_last;
} shared;
struct list_head anon_vma_chain;
struct anon_vma* anon_vma;
const struct vm_operations_struct* vm_ops; //vma对应的实际操作
unsigned long vm_pgoff; //⽂件映射偏移量
struct file* vm_file; //映射的⽂件
void* vm_private_data; //私有数据
atomic_long_t swap_readahead_info;
#ifndef CONFIG_MMU
struct vm_region* vm_region; /* NOMMU mapping region */
#endif
#ifdef CONFIG_NUMA
struct mempolicy* vm_policy; /* NUMA policy for the VMA */
#endif
struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
} __randomize_layout;所以我们可以对上图在进行更细致的描述，如下图所示：
3.4 为什么要有虚拟地址空间
这个问题其实可以转化为：如果程序直接可以操作物理内存会造成什么问题？
在早期的计算机中，要运行一个程序，会把这些程序全都装入内存，程序都是直接运行在内存上的，也就是说程序中访问的内存地址都是实际的物理内存地址。当计算机同时运行多个程序时，必须保证这些程序用到的内存总量要小于计算机实际物理内存的大小。
那当程序同时运行多个程序时，操作系统是如何为这些程序分配内存的呢？例如某台计算机总的内存大小是128M，现在同时运行两个程序A和B，A需占⽤内存10M，B需占用内存110。计算机在给程序分配内存时会采取这样的方法：先将内存中的前10M分配给程序A，接着再从内存中剩余的118M中划分出110M分配给程序B。
- 安全风险
每个进程都可以访问任意的内存空间，这也就意味着任意一个进程都能够去读写系统相关内
存区域，如果是一个木马病毒，那么他就能随意的修改内存空间，让设备直接瘫痪。
- 地址不确定
众所周知，编译完成后的程序是存放在硬盘上的，当运行的时候，需要将程序搬到内存当中
去运行，如果直接使用物理地址的话，我们无法确定内存现在使用到哪里了，也就是说拷贝
的实际内存地址每一次运行都是不确定的，比如：第一次执行a.out时候，内存当中一个进程
都没有运行，所以搬移到内存地址是0x00000000，但是第二次的时候，内存已经有10个进程
在运行了，那执行a.out的时候，内存地址就不一定了
- 效率低下
如果直接使用物理内存的话，一个进程就是作为一个整体（内存块）操作的，如果出现物理
内存不够用的时候，我们一般的办法是将不常用的进程拷贝到磁盘的交换分区中，好腾出内
存，但是如果是物理地址的话，就需要将整个进程一起拷走，这样，在内存和磁盘之间拷贝
时间太长，效率较低。
有了虚拟地址空间和分页机制就能解决了
- 地址空间和页表是OS创建并维护的！就意味着，凡是想使用地址空间和页表进行映射，也一定要在OS的监管之下来进行访问！！也顺便保护了物理内存中的所有的合法数据，包括各个进程以及内核的相关有效数据！
- 因为有地址空间的存在和页表的映射的存在，我们的物理内存中可以对未来的数据进行任意位置的加载！物理内存的分配 和 进程的管理就可以做到没有关系，进程管理模块和内存管理模块就完成了解耦合。
因为有地址空间的存在，所以我们在C、C++语言上new, malloc空间的时候，其实是在地址
空间上申请的，物理内存可以甚至一个字节都不给你。而当你真正进行对物理地址空间访问
的时候，才执行内存的相关管理算法，帮你申请内存，构建页表映射关系（延迟分配），这
是由操作系统自动完成，用户包括进程完全0感知！！
- 因为页表的映射的存在，程序在物理内存中理论上就可以任意位置加载。它可以将地址空间上的虚拟地址和物理地址进行映射，在进程视角所有的内存分布都可以是有序的。
最后
本篇关于命令行参数、环境变量和进程地址空间的内容到这里就结束了，其中还有很多细节值得我们去探究，需要我们不断地学习。如果本篇内容对你有帮助的话就给一波三连吧，对以上内容有异议或者需要补充的，欢迎大家来讨论！