Linux 是一个基于文件的操作系统
操作系统需要和硬件进行交互，对应 Linux 来说这些硬件都是文件，比如：操作系统会将 硬盘 , 鼠标 , 键盘 , 显示屏等抽象成一个设备文件来进行管理。
Linux 操作系统是一种自由软件，是免费的，并且公开源代码。
可以同时登陆多个用户，并且每个用户可以同时运行多个应用程序。
提供了友好的图形用户界面，操作简单， 易于快速上手。
支持多平台（这里指的是基于不同 CPU 架构的平台，比如国产 Linux 使用的龙芯等）
UNIX体系结构
内核：控制计算机运行资源，提供程序运行环境
系统调用：内核的接口
共用库函数：共用库函数构建在系统调用的接口上
shell：shell是一个特殊的应用程序，为运行其他的应用程序提供接口
Linux 系统从应用角度来看，分为内核空间和用户空间两个部分。内核空间是 Linux 操作系统的主要部分，但是仅有内核的操作系统是不能完成用户任务的。丰富并且功能强大的应用程序包是一个操作系统成功的必要件。这个和武林秘籍一样，不仅得有招式还得有内功心法。
Linux 的内核主要由 5 个子系统组成：进程调度、内存管理、虚拟文件系统、网络接口、进程间通信。下面将依次讲解这 5 个子系统。
SCHED_OTHER：分时调度策略（默认），是用于针对普通进程的时间片轮转调度策略。
SCHED_FIFO：实时调度策略，是针对运行的实时性要求比较高、运行时间短的进程调度策略
SCHED_RR：实时调度策略，是针对实时性要求比较高、运行时间比较长的进程调度策略。
内存管理是多个进程间的内存共享策略。在 Linux 中，内存管理主要说的是虚拟内存。
虚拟内存可以让进程拥有比实际物理内存更大的内存，可以是实际内存的很多倍。
每个进程的虚拟内存有不同的地址空间，多个进程的虚拟内存不会冲突。
在 linux 中根目录的子目录结构相对是固定的 (名字固定), 不同的目录功能是也是固定的
bin: binary, 二进制文件目录，存储了可执行程序，今天要将的命令对应的可执行程序都在这个目录中
sbin: super binary, root 用户使用的一些二进制可执行程序
etc: 配置文件目录，系统的或者用户自己安装的应用程序的配置文件都存储在这个目录中
lib: library, 存储了一些动态库和静态库，给系统或者安装的软件使用
media: 挂载目录，挂载外部设备，比如：光驱，扫描仪
mnt: 临时挂载目录，比如我们可以将 U 盘临时挂载到这个目录下
proc: 内存使用的一个映射目录，给操作系统使用的
tmp: 临时目录，存放临时数据，重启电脑数据就被自动删除了
boot: 存储了开机相关的设置
home: 存储了普通用户的家目录，家目录名和用户名相同
root: root 用户的家目录
dev: device , 设备目录，Linux 中一切皆文件，所有的硬件会抽象成文件存储起来，比如：键盘， 鼠标
lost+found: 一般时候是空的，电脑异常关闭 / 崩溃时用来存储这些无家可归的文件，用于用户系统恢复
opt: 第三方软件的安装目录
var: 存储了系统使用的一些经常会发生变化的文件， 比如：日志文件
usr: unix system resource, 系统的资源目录
/usr/bin: 可执行的二进制应用程序
/usr/games: 游戏目录
/usr/include: 包含的标准头文件目录
/usr/local: 和 opt 目录作用相同，安装第三方软件
环境变量表：PATH=/bin:/usr/bin:/usr/local/bin:. PATH 变量包含了一张目录表(称为路径前缀)，目录之间用冒号(:)分隔。
登录名、加密口令、数字用户ID、数字组、注释字段、起始目录、shell程序
dyc:x:205:105:trdycdyc:/home/dyc:/bin/dsh
分为两种： 1、和用户交互的交互式shell。 2、 文件类型的shell脚本
文件描述符(fledescriptor)通常是一个小的非负整数，内核用以标识一个特定进程正在访问的文件。当内核打开一个现有文件或创建一个新文件时，它都返回一个文件描述符。在读、写文件时，可以使用这个文件描述符。
每当运行一个新程序时，所有的shell都为其打开3个文件描述符，标准输入、输出、错误，默认情况下这三个文件描述符都会链接向终端，shell也提供了一种方法（重定向符”>“），是这三个文件描述符重新定向到某个文件，当重定向的文件不存在时，shell会创建它。
编写代码可实现文件的复制
./a.out < infile > outfile
函数open、read、write、lseek以及close提供了不带缓冲的IO
标准IO为那些不带缓冲的IO提供了一个带缓冲的接口，这样就无需选择最佳的缓冲区大小
程序是一个存储在磁盘上某个目录中的可执行文件，内核使用exec函数将程序读入内存，并执行
程序的执行实例叫进程，进程ID唯一标识了每个进程
主要用到三个函数：fork、exec、waitpid
一个进程内的所有线程共享同一地址空间、文件描述符、栈、以及与进程相关的属性
在<errno.h>中定义了errno以及可以赋予它的各种常量，这些常量都是以字符E开头的
errno并不是简单的一个数据结构，也不是一个int类型的变量，而是一个宏，下面是其实现
extern int *__errno_location(void);
#define errno (*__errno_location())
c标准提供了两个函数，用于打印出错消息
#include<string.h>
char *strerror(int errnum);
perror函数基于errno当前值，在标准错误上产生一条出错消息字符串，并返回此字符串的指针
#include<stdio.h>
void perror(const char *msg)
**注意：**只有当一个库函数失败时，errno才会被设置。当函数成功运行时，errno的值不会被修改。这意味着我们不能通过测试errno的值来判断是否有错误存在。反之，只有当被调用的函数提示有错误发生时检查errno的值才有意义。
用户ID、组ID、附属组ID
信号用于通知进程发生了某种情况，常见的信号处理方式有以下三种
终端键盘提供了产生两种信号的方法：中断键（ctrl + c）和退出键（ctrl + \）
另一种时调用kill产生信号，例如在一个进程中调用此函数就可以向另一个进程发送信号
历史上，共有两种时间：
度量一个进程的执行时间，用三个时间值：
#include<assert.h> //验证程序断言
#include<errno.h> //出错码
#include<stdio.h> //标准I/O库
#include<stdlib.h> //使用函数
#include<string.h> //字符串操作
#include<time.h> //时间和日期
#include<wchar.h> //宽字符类型
#include<dirent.h> //目录项
#include<fcntl.h> //文件控制
#include<netdb.h> //网络数据库操作
#include<pthread.h> //线程
#include<unistd.h> //符号常量
#include<arpa/inet.h> //因特网定义
#include<net/if.h> //套接字本地接口
#include<sys/select.h> //select函数
#include<sys/socket.h> //套接字接口
#include<sys/stat.h> //文件状态
#include<sys/types.h> //基本系统数据类型
#include<sys/un.h> //UNIX域套接字定义
#include<unistd.h>
long sysconf(int name);
long pathconf(const char *pathname, int name);
long fpathconf(int fd, int name);
这些函数用来修改一些系统配置，例如进程最大打开文件数、进程最大信号量等
POSIX是一个最初由IEEE制定的标准族，指的是可以指操作系统接口（Portable Operating System Interface），该标准以UNIX为基础，但是并不限于UNIX类系统。
对于内核而言，所有打开的文件都用文件描述符引用。文件描述符是一个非负整数。
按照习惯，UNIX系统shell把文件描述符0与进程的标准输入关联，文件描述符1与进程的标输出关联，文件描述符2与进程的标准错误关联，在哟应用程序中，我们应该将他们替换为STDIN_FILENO、STDOUT_FILENO、STDERR_FILENO以提高程序可读性。这些常量定义在<unistd.h>中，文件描述符，最多打开63个。
#include<fcntl.h>
int open(const char *path, int oflag, ...)
int openat(int fd, const char *path, int oflag,...)
两个函数的返回值：若成功，返回文件描述符;若出错，返回-1
由open和openat函数返回的文件描述符一定是最小的未用的描述符，
#include<fcntl.h>
int creat(const car *path, mode_t mode)
此函数可以被open函数完全替代，这里不作介绍。
#include<ubnnistd.h>
int close(int fd);
当一个进程终止时，内核自动关闭它所有打开的文件，关闭文件时还会释放该进程加上去的所有记录锁。
每打开文件，内核都会维护一个与其相关联的“当前文件偏移量”，通常读、写操作都是从当前文件偏移量处开始，并使偏移量增加所读写的字节数。可以调用lseek显示地为一个文件设置偏移量。
#include<unistd.h>
off_t lseek(int fd, off_t offset, int whence);
//返回值：若成功，返回新的文件偏移量，若出错，返回-1
参数whence：
通常文件的当前偏移量应该是一个非负整数，但是某些设备也允许福德偏移量，因此，在比较lseek的返回值时应该谨慎，不要测试它是否小于0，而要测试是否等于-1。
文件偏移量可以大于文件的当前长度，在这种情况下，对该文件的下一次写将加长该文件，并在文件中构成一个空洞，这一点是允许的，在文件中但没有被写过的字节都被读为0. 空洞并不要求在磁盘上占用存储区。
#include<unistd.h>
/*不带缓冲的IO*/
ssoze_t read(int fd, void *buf, size_t nbytes);
ssize_t write(int fd, const void *buf, size_t nbytes);
//返回值：读到的字节数，若以到文件尾，返回0；若出错，返回-1
系统CPU时间的几个最小值差不多出现在BUFFSIZE为4096以后，继续增加缓冲区长度对长度几乎没有效应影响。
内核使用三种数据结构表示打开的文件，
a. 文件描述符标志（close_on_exec）
b.指向一个文件表项的指针。
a. 文件状态标志（读、写、添加、同步和非阻塞等）
b.当前文件偏移量；
c.指向该文件v结点表项的指针
每个打开文件都有一个v节点结构。v节点包含了文件类型和对文件进行各种操作函数的指针。对于大多数文件，v节点还包含了该文件的i节点。
对于多个打开的文件
在每次完成write操作后，当前表项的中当前文件的文件偏移量即增加的字节数，如果超出了当前文件长度，则i节点中的当前文件长度也会同步更新。
lseek函数只修改文件表项中的当前文件偏移量，不进行任何I/O操作
当多个进程同时写一个文件时，逻辑操作“先定位到文件尾端，然后写”的逻辑操作会使后一个写的覆盖掉前一个写的内容，解决问题的方法就是将定位到文件尾端+写操作 对于其他进程来说为一个原子操作。在打开文件时设置O_APPEND标志，在每次写时，内核都会先将当前文件偏移量设置到该文件的尾端，这样就不用调用lseek函数了。
#include <unistd.h>
ssize_t pread(int fd, void *buf, size_t nbytes, off_t offset);
返回值：读到的字节数，若已到文件尾，返回0；若出错，返回-1
ssize_t pwrite(int fd, const void *buf, size_t nbytes, off_t offset);
返回值：若成功，返回已写的字节数；若出错，返回-1
针对这两个函数，需要注意的是：
#include<unistd.h>
int dup(int fd);
int dup2(int fd, int fd2);
//两个函数的返回值：若成功，返回新的文件描述符；若出错，返回-1
dup和dup2函数都用来复制一个指定的文件描述符，dup2函数可以指定返回的文件描述符fd2，如果fd2已经打开，则要想将其关闭。复制文件描述符的另一种方法是使用fcntl函数，这个将在后面介绍。
传统的UNIX系统实现在内核中设有缓冲区高速缓存或页高速缓存，大多数磁盘I/O都通过缓冲区进行。当我们像文件写入数据时，通常都先写入高速缓存（为了效率），然后再排队，晚些再写入磁盘。这种方式称为延迟写。
内核需要重用缓存区时，他会把所有延迟写 数据块写入磁盘。为了保证磁盘实际数据和缓存区的内容一致性，UNIX系统提供了sync、fsync和fdatasync三个函数
#include <unistd.h>
int fsync(int fd);
int fdatasync(int fd);
返回值：若成功，返回0；若失败，返回-1
void sync(void)
sync只是将所有修改过的块缓冲区排入写队列，然后就返回，并不等待实际写磁盘结束。
通常，称为update的守护进程周期性的调用sync函数，这就保证了可以定时冲洗内核的块缓冲区。
fsync函数只对文件描述符fd指定的一个文件起作用，并等待写磁盘结束才返回，比如数据库操作需要调用此函数。
fcntl函数可以改变已经打开文件的属性
#include<fcntl.h>
int fcntl(int fd, int cmd, .../*int arg*/);
//返回值：若成功，则依赖于cmd；若出错，返回-1
fcntl的返回值与命令有关。如果出错，所有命令有返回-1，成功则返回值其他值。
ioctl函数是I/O操作的杂物箱。
#include<unistd.h>
#include<sys/ioctl.h>
int ioctl(int fd, int request,...);
//返回值：若出错，返回-1；若成功，返回其他值
系统都会提供/dev/fd的目录，打开文件dev/fd/n等效于复制文件描述符n
例如fd = open("dev/fd/0",等效于fd = dup(0);值得注意的是/dev/fd在linux中是指向底层物理文件的，操作不当可能会造成底层截断。
例如，命令filter file2 | cat file1 - file3 | lpr与filter file2 | cat file1 /deb/fd/0 file3 | lpr相比，缺少了文件名参数的一致性。
该命令的解释：cat读file1，接着读其标准输入（也就是filter file2命令的输出），然后读file3文件
#include<sys/stat.h>
int stat(const char *restrict pathname, struct stat *restrict buf);
int fstat(int, struct stat *buf);
int lstat(const char *restrict pathname, struct stat *restrict buf);
int fstat(int fd, const char *restrict pathname, struct sat *restrict buf, int flag);
文件类型包括以下几种：
新文件的用户ID设置为进程的有效用户ID。关于组ID，用户可以选择：1. 新文件的组ID可以是进程的有效组ID.2.新文件的组ID可以是他所在的目录的组ID。
#include<unistd.h>
int access(const char *pathname, int mode);
int faccessat(int fd, const char *pathname, int mode, int flag);
//两个函数返回值：若成功，返回0；若出错，返回-1
#include<sys/stat.h>
mode_t umask(mode_t cmask);
//返回值：之前的文件模式创建屏蔽字
参数cmask是由图4-6中列出的9个常量中的若干位按照“或”构成的
在进程创建一个新文件或新目录时，就一定会使用文件模式创建屏蔽字，
下面程序创建两个文件，创建第一个时，umask为0.创建第二个时，umask值禁止所有组合和其他用户的访问权限。
#include<unistd.h>
#include<stdio.h>
#include<fcntl.h>
#define RWRWRW (S_IRUSR|S_IWUSR|S_IWGRP|S_IRGRP|S_IROTH|S_IWOTH)
int main(void)
{
umask(0);
if(creat("foo",RWRWRW) < 0)
err_sys("creat error for foo");
uamsk(S_IWGRP|S_IRGRP|S_IROTH|S_IWOTH);
if(creat("bar",RWRWRW) < 0)
err_sys("creat error for bar");
exit(0);
}
这三个函数是我们可以更改现有文件的访问权限
#include<sys/stat.h>
int chmod(const char *pathname, mode_t mode);
int fchmod(int fd, mode_t mode);
int fchmodat(int fd, const char *pathname, mode_t mode, int flag);
// 成功返回0；出错，返回-1
chmod函数在指定文件上进行操作，而fchmod函数则是对已经打开的文件进行操作。
下面这几个chown函数可用于更改文件的用户ID和组ID。
#include <unistd.h>
int chown (const char *pathname, uid_t owner, gid_t group) ;
int fchown(int fd, uid_t owner, gid_t group) ;
int fchownat(int fd, const char *pathname, uid_t owner, gid_t group, int flag) ;
int lchown (const char *pathname, uid_t owner, gid_t group) ;
//4个函数的返回值：成功，返回0；失败，返回-1
stat结构成员st_size表示亿字节为单位的文件长度。此字段只对普通文件、目录文件和符号链接有意义。
当文件中存在空洞时，实际长度可能和ls -l所得到的不相同，这是正常现象，当复制一个文件时，所有的空洞都会按实际字节被填充为0
有时我们需要在文件尾端出截取一些数据以缩短数据。将一个文件的长度截断为0是一个特例，再打开文件使用O_TRUNC标志可以做到这一点，为了截断文件可以调用函数truncate和ftruncate。
#include<unistd.h>
int truncate(const char *pathname, off_t length);
int ftruncate(int fd, off_t length);
//两个函数返回值：若成功，返回0；若出错，返回-1
磁盘、分区和文件系统
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uNmKp1dS-1668346492367)(D:\file\课程\md\image-20221106172800189.png)]
如果更仔细的观察一个柱面组的i节点和数据块部分，则可以看出如下图所示情况。
..以及在该目录中的.项。如果文件有一个子目录，则数值应该为3，另一个为其子目录中的..。注意，每个子目录又会使父目录的引用计数增加1。#include<unistd.h>
int link(const char *existingpath, const char *newpath);
int linkat(int efd, const char *existingpath, int nfd, const char *newpath, int flag);
//两个函数的返回值：若成功，返回0；若出错，返回-1
这两个函数都用来创建一个新目录想newpath，他引用现有文件existingpath。
为了删除一个现有的目录项，可以调用unlink函数
#include<unistd.h>
int link(const char *pathname);
int linkat(int efd, const char *pathname, int flag);
//两个函数的返回值：若成功，返回0；若出错，返回-1
unlink的这种特性经常被程序用来确保即使在程序崩溃时，她所创建的临时文件也不会遗留下来。进程用open或creat创建一个文件，然后立即调用unlink，引文该文件仍然是打开的，所以不会将其删除，只有当进程终止时（内核会关闭打开的所有文件描述符），该文件才会删除。
#include<stdio.h>
int remove(const char *pathname);
//返回值：若成功，返回0；出错，返回-1
文件或者目录可以用rename函数或者renameat函数重命名
#include<stdio.h>
int rename(const char *pathname);
int renameat(int oldfd, const char *oldname, int newflag，const char *newname);
//两个函数的返回值：若成功，返回0；若出错，返回-1
用mkdir和mkdirat函数创建目录，用rmdir函数删除目录
#include<sys/stat.h>
int mkdir(const char *pathname, mode_t mode);
int mkdirat(int fd, const char *pathname, mode_t mode);
// 两个函数的返回值：若成功，返回0；若出错，返回-1
两个函数创建一个新的空目录。其中.和 ..自动创建。访问权限由mode指定，对于牡蛎，通常至少要设置一个执行权限位，以允许访问该目录中的文件。
#include<unistd.h>
int rmdir(const char *pathname);
//函数的返回值：若成功，返回0；若出错，返回-1
st_dev和st__rdev这两个字段经常引起混淆。
在第三章，所有I/O函数都围绕文件描述符的，而对于标准I/O库，他们操作都是围绕流进行的，当标准I/O库打开或创建一个文件时，我们已使一个流与一个文件相关联。
我们称指向FILE对象的指针（FILE *）为文件指针。
这里有必要科普一下流和文件描述符的区别：
任何操作系统，在程序访问（读写）时，都需要建立程序与文件之间的通道，这一过程称之为打开文件。UNIX提供了两种机制，分别为：（1）文件描述符。（2）流。
两者的相同点：
两者不同点：
两者的关系：
流为用户提供了一些更高一级的I/O接口，它处在文件描述符的上层，也就是说流是通过文件描述符来实现的。
对一个进程预定义了3个流，并且这3个流可以自动被进程使用。这3个标准I/O流通过预定义文件指针stdin、stdout和stderr加以引用，这三个文件指针定义在头文件<stdio.h>中。
标准I/O库提供缓冲的目的是尽可能减少使用read和write调用的次数。他也对每个I/O流自动地进行缓冲管理，从而避免不必要的麻烦。遗憾的是，标准I/O库最令人迷惑的也是他的缓冲。
标准I/O提供了以下3种类型的缓冲。
#include<stdio.h>
FILE *fopen(const char *restrict pathname, const char *restrict type);
FILE *freopen(const char *restrict pathname, const char *restrict type, FILE *restrict fp);
FILE *fdopen(in//三个函数的返回值：若成功，则返回0；若出错，则返回-1
调用fclose函数关闭流
#include<stdio.h>
int fclose(FILE *fp);
//返回值：若成功，则返回0；若出错，则返回-1
再关闭文件之前，冲洗缓冲中的输出数据。缓冲区中的任何输入数据则被丢弃。如果标准I/O库以为该流自动分配了一个缓冲区，则释放此缓冲区。当一个程序正常终止时，所有的流都会被正确关闭。
#include<stdio.h>
int getc(FILE *fp);
int fgetc(FILE *fp);
int getchar(void);
//若成功，返回c；若出错，返回EOF
#include<stdio.h>
int putc(int c, FILE *fp);
int fputc(int c, FILE *fp);
int putchar(int c);
//若成功，返回c；若出错，返回EOF
#include<stdio.h>
char *fgets(char *restrict buf, int n, FILE *restrict fp);
char *gets(char *buf);
//若成功，返回buf;若已到达文件尾端或者出错，返回NULL
gets函数从标准输入读，而fgets函数从指定的流读。gets有些不安全，是不建议使用的
#include<stdio.h>
int *fputs(char *restrict str, FILE *restrict fp);
int *puts(char *str);
//若成功，返回buf;若已到达文件尾端或者出错，返回NULL
5.6和5.7节中的函数，因为各自的特点均不适合读写二进制I/O函数，因此特地提供以下两个函数进行二进制I/O
#include<stdio.h>
size_t fread(void *restrict ptr, size_t size, size_t nobj, FILE *restrict fp);
size_t fwrite(const void *restrict ptr, size_t size, size_t nobj, FILE *restrict fp);
//返回值：读写的对象数
此函数常见的两种用法。
float data[10];
if(fwrite(&data[2], sizeof(float), 4, fp) != 4)
perror("fwrite error");
struct {
short count;
long total;
char name[NAMESIZE];
}item;
if(fwrite(&item, sizeof(item), 1, fp) != 1)
perror("fwrite error");
使用二进制I/O的基本问题是，它只能用于都在同一系统上已写的数据。具体表现为，在一个系统上写的数据，在另一个系统上进行处理，此时会出问题，不能正常工作，其原因包括：
格式化输出由5个printf函数来处理的。
#include<stdio.h>
int printf(const char *restrict format, ...);
int fprintf(FILE *restrict fd, const char *restrict format, ...);
int dprintf(int fd, const char *restrict format, ...);
//3个函数的返回值：成功，返回输出字符数，若输出错误，返回负值
int sprintf(char *restrict buf, const char *restrict format, ...);
//返回值：成功，返回存入数组的字符数，若编码错误，返回负值
int snprintf(char *restrict buf, size_t n, const char *restrict format, ...);
//返回值：若缓冲区足够大，返回将要存入数组的字符数，若编码错误，返回负值
printf函数将格式化数据写到标准输出，fprintf写至指定的流，dprintf写至指定的文件描述符，sprintf将格式化的数据写入数组，同时在该数组的尾端自动加一个null字节，但该字符不包括到返回值中。snprintf函数显式的提供了缓冲区的长度，以防止缓冲区溢出的隐患，但是此函数不会再数组最后加NULL字节。
格式说明控制其余参数如何编写，以后如何显示，转换说明是以%开始的。一个转换说明有4个可选择的部分。具体说明和示例见来链接：https://blog.csdn.net/weixin_44567318/article/details/115441167。
#include<stdio.h>
int scanf(const char *restrict format, ...);
int fscanf(FILE *restrict fp, const char *restrict format, ...);
int sscanf(const char *restrict buf, const char *restrict format, ...);
#include<stdio.h>
int fileno(FILE *fp);
//返回值：与文件相关联的文件描述符
有UNIX提供的基本时间服务是自1970年00：00：00这一特定时间以来提供的秒数。
time函数返回当前的时间和日期
#include<time.h>
time_t time(time_t *calptr);
//返回值：成功，返回时间数，若参数列表非空，返回值也会保存到参数列表的指针中；失败，返回-1
两个函数localtime和gmtime将日历时间转换为分解后的时间，并将其存放在一个tm的时间结构中。
struct tm{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year
/**还包括夏令时间**/
...
};
#include<time.h>
struct tm *gmtime(const time_t *calptr);
struct tm *localtime(const time_t *calptr);
C程序总是从main函数开始的。main函数的原型是:
int main(int argc, char *argv[]);
argc 是命令行的参数，argv是指向参数的哥哥指针多构成的数组。
当内核执行一个C程序时（使用exec函数），调用main前先调用一个特殊的启动例程。可执行文件将此启动例程指定为程序的起始地址。启动例程从内核取得命令行参数和环境变量值，然后为按照上述方式调用main函数做好安排。
有8种方式是进程终止，其中5种为正常终止，他们是：
异常终止方式包括三种：
启动例程是这样编写的：使得从main函数返回后立即调用exit函数。该例程通常使用汇编语言编写的
退出函数
3个函数用于正常终止一个程序：_exit和 _Exit立即进入内核，exit则先执行一些清理处理，然后返回内核。
#include<stdlib.h>
void exit(int status);
void _Exit(int status);
#include<uistd.h>
void _exit(int status);
exit函数总是会先执行一个标准I/O库的清理关闭操作。
3个退出函数都会带一个整形参数，称为终止状态。大多数UNIX系统都提供了检查进程终止状态的方法。
函数atexit
按照ISO C一个程序最多可以登记32个函数，这些函数有exit自动调用，我们称这些函数为终止处理函数。并调用atexit来登记这些函数。
#include<stdlib.h>
int atexit(void (*func)(void));
//返回值：成功，返回0，若出错，返回-1
其中，atexit函数的参数是一个函数地址，exit函数调用这些函数的顺序预登记时顺序相反，同意函数如果登记多次，那么也会调用多次。
根据ISO C和POSIX.1，exit首先谁调用各种终止处理程序，然后关闭所有打开流，此外若程序调用exec函数族，则将清除所有已安装的终止处理函数。
注意，内核使程序执行的唯一方法是调用exec函数。进程终止的唯一方法是显式或隐式的调用_exit或 _Exi。进程也可以通过信号的方式非自愿终止。
当执行一个程序时，调用exec的进程可将命令行参数传递给新程序。
ISO C和POSIC.1 都要求argv[argc]是一个空指针。这就使得我们可以将参数处理循环写为：
for(i = 0; argv[i] != NULL; i++)
每个程序都接收到一张环境表，环境表也是一个字符指针数组，全局变量environ则包含了该指针数组的地址：extern char **environ;每个指针包含了一个以null结尾的C字符串的地址。
通常用getenv和putenv来访问指定的环境变量。
C程序一直由以下几部分组成：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3oRsQuIS-1668346492369)(D:\file\课程\md\3.png)]
size命令报告了正文段、数据段和bss段的长度（以字节为短）。
这里需要补充几点：
共享库使得可执行文件不再需要包含公共的库函数，而只需要在所有进程都可引用的存储区中保持这种库例程的一个副本。程序第一次执行或者调用某个库函数时，用动态链接方法将程序与共享 库函数相链接。这减少每个可执行文件的长度，但增加了一些运行时间开销。例如编译如下程序：
$ gcc -static hello1.c 阻止gcc使用共享库
a.out -> 979443
$ gcc hello1.c gcc使用共享库
a.out -> 8378
可以看出，使用共享库编译此程序，可执行文件的正文和数据段的长度都显著减小；
ISO C说明了三个用于存储空间动态分配的函数
#include<stdlib.h>
void *malloc(size_t size);
void *calloc(size_t nobj, size_t size);
void *realloc(void *ptr, size_t newsize);
//成功返回非空指针，若出错，返回NULL
void free(void *ptr);
因为这三个alloc函数都返回void*， 所以若果程序中包含了#include<stdlib.h>，那么当我们i将这些返回赋予一些其他类型时，就不需要显式的强制类型转换了。
大多数实现所分配的存储空间比所要求的要稍大一些，额外的空间用来记录管理信息——分配块的长度、指向下一个分配块的指针等，这就意味着，如果超过一个已分配区的尾端或者起始位置首端，则会造成在灾难性问题。
其他可能产生致命性错误的是：释放一个已经释放的块；调用free时使用的指针不是alloc函数返回值等。弱国一个进程调用malloc函数，但是忘了调用free函数，那么该进程占用的存储空间就会连续增大，这被称为泄露。
ISO C定义使用getenc函数来获取环境变量得值，注意，此函数返回一个指针，指向name=value中得value，而且获取得是一个副本，而不是直接访问environ的。
#include<stdlib.h>
char *getenv(const char *name);
//返回值：指向name对应value的指针，若未找到，返回NULL
此外，还可以修改环境变量的值：
#include<stdlib.h>
int putenv(char *str);
int setenv(const char *name, const char *value, int rewrite);
int unsetenv(const char *name);
在C中，goto语句不能跨越函数的，而执行这种跳转功能的函数时setjmp和longjmp。
#include<setjmp.h>
int setjmp(jmp_buf env);
void longjmp(jmp_buf env, int val);
每个进程都有一组资源限制，其中一些可用以下两个函数执行
#include<sys/resource.h>
int getgetrlimit(int resource, struct rlimit *rlptr);
int setrlimit(int resource, const struct rlimit *rlptr);