进程之IPC通信二

4.共享内存

共享内存是进程间通信一种方式，多个进程共享一段内存，“ 共享内存 ”。由于多个进程共享了同一段内
存，这个段内存既是你的也是我的。也就是你往这个内存里面写入数据，实际上就相当于往我的内存里
面写入数据。比起其他 IPC 方式（ pipe fifo message.. ）少拷贝操作，相对而言共享内存的效率高于其
他的。
共享内存的生存期：随内核持续性

实现方式：

• 在内核中开辟一块共享内存，其他的进程通过 “ 映射 ” 方式，获取这个段共享内存的引用（指针）
• 进程 P1 可以映射这段内存，同时其他的进程（如： P2..Pn ）也可以映射这段内存， P1 往内存里面写入数据，实际就是往P2..Pn进程中写入数据，反之亦然

System V 和POSIX两套方法

4.1 System V共享内存的API

System V （ msg/shm/sem ）操作流程：

4.1.1 创建或者是打开一个IPC 设施

ftok ：创建或者是打开一个IPC设施( msg/shm/sem )也就是一个 System V IPC 对象的" 钥匙 "（ KEY ）

• 函数原型

#include <sys/types.h>#include <sys/ipc.h>key_t ftok(const char *pathname, int proj_id);

• 函数描述

创建或者是打开一个IPC设施(msg/shm/sem)也就是一个System V IPC对象的"钥 匙"（KEY )

• 参数

  • pathname： 一个在文件系统中路径名（这个路径必须要存在） 创建或打开System V 共享内存

    • shmget ：通过ftok获取到的 IPC 设施的钥匙来创建或打开一个System V共享内存 映射/解映射

      • 映射：把内核或者设备的文件中的一段内存映射到进程的地址空间去，用进程的一个指针，去 访问这段 内存。

    • shmat ：通过拿到的共享内存 ID 映射共享内存

  • proj_id:0 int

    • 类型整数，一般用工程的代号。

• **返回值 ** @return

  • 成功生成一个唯一的System V的IPC设施的KEY
  • 失败返回-1，同时errno被设置

4.1.2 创建或打开System V 共享内存

shmget ：通过 ftok 获取到的 IPC 设施的钥匙来创建或打开一个 System V 共享内存

• 函数原型

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);

• 函数描述：

  shmget用来在内核中创建或打开一个SystemV的共享内存

• 参数

• @key： System V的IPC设施的KEY，一般由ftok返回

• @size： 字节单位，指定共享内存区域的字节大小

• @shmflg： 标志位

  • （1）创建：IPC_CREAT | 权限位
  • （ 2）打开：0

• 参数 @return：

  • 成功返回共享内存区域的ID号，这个ID就唯一标识了这个共享内存

  • 失败返回-1，同时errno被设置

4.1.3 映射/解映射

映射：把内核或者设备的文件中的一段内存映射到进程的地址空间去，用进程的一个指针，去访问这段
内存。
shmat ：通过拿到的共享内存 ID 映射共享内存

• 映射函数原型

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);

• 函数描述

  • 用来映射一段System V的共享内存

• 参数

  • @shmid: 要映射的那个共享内存的id号，一般由shmget返回

  • @shmaddr：指定要映射到的进程的哪个地址上去

    一般为NULL，由系统自个决定。

  • @shmflg：标志位：

    • SHM_RDONLY 只读
    • 读写：0

• 返回值 @return：

  • 成功返回映射成功的首地址
  • 失败返回NULL，同时errno被设置。

• 解映射函数原型

 #include <sys/types.h>#include <sys/shm.h>
int shmdt(const void *shmaddr);  

• 函数描述：
  • 解除一段共享内存的映射
• 参数
  • @shmaddr需要解除映射的内存首地址。
• 返回值
  • 成功返回
  • 失败返回-1，同时errno被设置

4.1.4其他操作

shmctl ：对于共享内存的操作的。

• 函数原型

#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

• 函数描述：

  • 对于共享内存的操作

  • 参数

  • @shmid：

    • 需要进程控制操作的共享内存id号

  • @cmd：

    command 操作命令，不同的命令第三个参数是不一样的。

    • IPC_RMID:

      删除指定的共享内存区域

    • 如果命令为IPC_RMID的话，第三个参数为：NULL

  • @buf：

    • 由第二个参数来决定第三个参数

​

• 返回值 @return：
  • 成功返0
  • 失败返-1，同时errno被设置。

示例

主进程

#include <iostream>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "System.h"
using namespace std;// 从进程
int main()
{cout << "从进程" << endl;// 申请IPC设施的keykey_t key = ftok(IPC_PATH, IPC_PROJ );// 获取主进程申请的 共享内存id号  大小是0，权限打开就可以int shm = shmget(key, 0 , 0);// 映射共享内存到用户空间int *p_shmat  =(int *)shmat(shm, nullptr, 0);//发送数据while(1){cout << "请输入：";cin >>  *p_shmat;//向共享内存输入内容if( *p_shmat == -1) break;}// 解除映射shmdt(p_shmat);// 不需要删除共享内存，主进程负责return 0;
}

从进程

#include <iostream>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "System.h"
using namespace std;
//主进程
int main()
{cout << "主进程" << endl;// 申请IPC设施的keykey_t key = ftok(IPC_PATH, IPC_PROJ );// 申请一个 System V 共享内存id号int shm = shmget(key, sizeof(int), IPC_CREAT | 0777);// 映射共享内存到用户空间int *p_shmat  =(int *)shmat(shm, nullptr, 0);int old = 0 ;while(1){if(*p_shmat == -1) break;if( *p_shmat != old ){cout << "来自从进程的内容:p_shmat < " << *p_shmat << " > "<< endl;old = *p_shmat;}}// 解除映射shmdt(p_shmat);//删除指定的共享内存区域shmctl(shm, IPC_RMID, nullptr);return 0;
}

5. 信号量

有两个以上的任务（进程/线程）并发的实体，去访问同一个共享资源（硬件上，软件上）的时候，那么 要保证访问的这个共享资源是有序访问，如果不是有序访问有可能造成不可预知后果。

// P1：
void readContent(){// 1.txtchar buffer[1024]={0};read(fd,buffer,1024);....
}// P2：
void writeContent(){// 1.txtchar buffer[1024]={"123"};write(fd,buffer,3);....}

有两个实例（任务），调用 readContent 函数，那么读出最后的值是多少。有可能是 123 也有可能是
其他值。
其他值不是我们想要的，所以我们要保证多个实例能够有序的去访问，就需要对共享资源进行某种保
护，以便实例可以有序的访问，避免竞争
分析：

• 并发---->竞争---->共享资源的非法访问 ---->程序行为异常…

解决方法：

• 能不能不用并发？
  • 显然不行
• 在保留并发前提下，“ 避免竞争 ” ===> 访问共享资源的时候，严格串行！！！！

5…1 信号量机制

信号量是个什么玩意？
信号量的作用是什么？
为什么要用到信号量？
信号量是怎么达到目的的？

5.1.1 信号量是个什么玩意？

信号量（semaphore）是一种用于提供不同进程的间或一个进程内部不同线程间的同步的一种机制。

• 进程/线程：任务，并发的实体
• 同步：并发实体间，相互等待相互约束的，有序的，有条件的访问。

信号量就是为了保护共享资源，让共享资源有序的访问的一种机制。
信号量目标：为了保护共享资源，使其能够被有序访问。
信号量是我们程序界最高尚的一种东西，因为它不是为了自己存在而存在，是为了别人而存在的。（它
保护的对象，共享资源）“ 保镖 ”

5.1.2 什么时候使用信号量？

• 有保护对象的时候，才需要信号量
• 首先搞清楚，谁需要保护，保护谁？
• 一个被保护对象，需要一个信号量。

5.1.3 如何来保护？

保护 是指，让这个被保护对象（ 共享资源 ）有序的访问。如： 互斥 ”
“ 共享资源 ”：大家都访问的资源。
信号量机制，其实是程序员之间的一种**约定，**用来保护共享资源的。比如说进程A和进程B，都要访问一
个互斥设备，那么我们可以使用一个信号量来表示能不能访问该设备，然后每个进程访问该设备的时
候，先去访问信号量，如果能访问设备就把信号量设置为“ NO ”，访问完毕之后再将信号量设置为 “YES
”。

在访问共享资源的时候，先去判断，共享资源是否能够访问。

• 能访问：你就获取到了该信号量（ 变成不可访问 ），则进入能访问之后的代码。
• 不能访问： wait 直到信号量变成：能访问。

访问共享资源的代码区域叫做：临界区

• LOCK 上锁
  • 操作共享资源的代码
• UnLOCK 解锁

5.1.4 信号量是如何实现的？

“ 信号量 ”：大家都可以访问的一个整数。
一个进程/线程可以在某个信号量上执行以下三种操作：

• 创建 ( create ) 一个信号量：这还要求调用者指定信号量的初始值。

  • 初始值表示该信号量保护的共享资源，可以同时被多少个任务访问。

  • sem –> 5 表示此刻有5个进程或者线程去同时访问它所保护的共享资源。

  • sem --> 1 表示此刻有一个进程或者线程可以去访问它所保护的共享资源。

    • ​ “ 互斥信号量 ”

• 等待（ wait ）一个信号量

  • 该操作会测试这个信号量的值，如其值 <= 0，那么会等待( 阻塞 )一旦其值>0,这个时候，将它-1，并继续往下执行临界区代码。

  • 其函数实现如下：

    • while(semaphore_value <= 0){// wait block .... 卡死在这里
      }semaphore_value--; // 表示该进程/线程获取到了信号量
      // 下面的代码就是对于获取到该信号了之后，对共享资源的操作。
      

  • 上述操作必须是 “ 原子操作 ”：不允许有两个及以上的进程同时操作。

  • P操作： proberen （ 尝试 ）荷兰语

    • down/lock 上锁

• ​ 释放一个信号量：**该操作将信号量的值+1，**其函数实现类型如下

  • semaphore_value++; // 原子操作
    

  • V操作： verhogen （ 增加 ）荷兰语

    • up / unlock 解锁

信号量保护的目标是通过如下方式实现：

• 在临界区的前面加上一个：P操作
• 在临界区的后面加上一个：V操作

5.2 Linux内核信号量的具体实现

• System V 信号量
• POSIX 信号量

5.2.1 System V semaphore

System V信号量的大概流程

• ftok ：获取 System V IPC 设施对象的key
• semget ：在内核中创建或打开一个 System V 信号量
• P/V操作

System V信号量

• 计数信号量集（计数信号量数组）：

• 计数信号量：

  • 该信号量的值可以是> 1 的值，它所保护共享资源允许多个任务同时访问它。

  • 计数值 1 , 0 ===> 互斥信号量

• 互斥信号量：

  • 该信号量的值要么是1，要么是0，它所保护的共享资源同一时刻只能允许一个任务访问。

为什么System V要把信号量弄成一个信号量集(信号量数组)呢？

• P(S1 & S2) 的这种情况…

5.3 信号量的API函数

SystemV IPC 信号量

semget

emget ：用来创建或打开一个**System V信号量

 #include <sys/types.h>#include <sys/ipc.h>#include <sys/sem.h>int semget(key_t key, int nsems, int semflg);/*作用：用来创建或打开一个System V信号量@key：System V IPC设施的key，有ftok返回@nsems：要创建的信号量集中的信号量的数量如果我们不是创建而是打开一个已经存在的信号量集，此处参数可以为0，一旦创建完成一个信号量集，其信号量的个数就不能改变了。@semflg：标志位：创建：IPC_CREAT | 权限位打开：0@return：成功返回System V信号量集的id号失败返回-1，同时errno被设置
*/

注意：在一个新创建的信号量集中的信号量的值，是不确定的。所以要初始化

semctl

semctl ：控制操作

 #include <sys/types.h>#include <sys/ipc.h>#include <sys/sem.h>int semctl(int semid, int semnum, int cmd, ...);/*作用：控制操作，设置或获取信号量集中某个或者某些信号量的值@semid：信号量集的id号，由semget返回@semnum：要操作的信号量集中的哪个信号量，就是信号量数组的下标，从0开始到nsems-1@cmd：command 命令，操作信号量集常用命令：GETVAL：获取第semnum哪个对应的信号量的值SETVAL：设置第semnum哪个对应的信号量的值GETALL：获取这个信号量集中的所有信号量的值SETALL：设置这个信号量集中的所有信号量的值IPC_RMID：删除这个信号量集...@...：针对不同的命令号，第四个参数不一样cmd == GETVAL第四个参数不需要cmd == SETVAL第四个参数表示位要设置的信号量的值cmd == GETALL第四个参数表示所有信号量的值，为：unsigned short vals[]...@return:根据命令不同，返回值的含义不一样如：如：GETVAL 返回信号量的值正常情况成功返回0，失败返回-1*/

semop

semop : System V 信号量的 PV 操作

#include <sys/types.h>#include <sys/ipc.h>#include <sys/sem.h>int semop(int semid, struct sembuf *sops, size_t nsops);
/*作用：System V信号量的PV操作@semid：需要PV操作的信号量集的id号@sops：用来描述System V的PV操作struct sembuf{unsigned short sem_num;    需要操作的信号量下标short sem_op;>0:表示V操作 解锁=0:表示try 尝试是否会阻塞<0:P操作，上锁semval(信号量的值) == 原semval + sem_opshort sem_flg;0:默认，如果P操作做不了，则会阻塞：死等IPC_NOWAIT:非阻塞不等待如果是P操作做不了，直接走人，能获取就获取。SEM_UNDO:撤销为了防止进程带锁退出。if you set SEM_UNDO这个标志，内核会额外记录该进程对信号量的所有PV操
作，然后再该进程退出的时候，会还原操作。如：// 正常情况P V P V kill-1 +1 -1 +1 0// 带锁退出P V P kill-1 +1 -1 (+1)}；int semtimedop(int semid, struct sembuf *sops, size_t nsops,const struct 
timespec *timeout);/*作用：限时等待@semid：需要限时等待的信号量集的id@sops：用来描述System V的PV操作@nsops：第二个参数的数量struct sembuf 是对于信号量集的PV操作，但是信号量集中不一定只有一个信号量，所以
PV操作也不止一个。@timeout：超时时间：struct timespec{long tv_sec; // 秒数long tv_nsec;// 纳秒1s ==> 1000ms1ms ==> 1000us1us ==> 1000ns}；如：struct timespec tv;tv.tv_sec = 5; // 五秒tv.tv_nsec = 0;*/

示例

System.h文件 共享内存通信所需的宏

#ifndef __SHM_H__
#define __SHM_H__#define IPC_PATH "/home/wanfeng"
#define IPC_PROJ 200206#endif 

主进程

#include <iostream>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include "System.h"
#include <unistd.h>
using namespace std;
//主进程
int main()
{cout << "主进程" << endl;// 申请IPC设施的keykey_t key = ftok(IPC_PATH, IPC_PROJ );//申请信号量int sem_id = semget(key, 2, IPC_CREAT | 0777 );// 初始化信号量int set_val1 = 1;int set_val2 = 0;semctl(sem_id, 0, SETVAL, set_val1);//（互斥锁）semctl(sem_id, 1, SETVAL, set_val2);//互斥信号锁// 申请一个 System V 共享内存id号int shm = shmget(key, sizeof(int), IPC_CREAT | 0777);// 映射共享内存到用户空间int *p_shmat  =(int *)shmat(shm, nullptr, 0);while(1){//  usleep(5000);//等待同步信号量struct sembuf sem_fp ;sem_fp.sem_num = 1;// 需要操作的信号量下标sem_fp.sem_op = - 1; // 上锁sem_fp.sem_flg = SEM_UNDO; //死锁的是时候撤销// 互斥锁上锁//  semop的第二个参数struct sembuf *sops成员struct sembuf sem_op ;sem_op.sem_num = 0;// 需要操作的信号量下标sem_op.sem_op = -1; // 上锁sem_op.sem_flg = SEM_UNDO; //死锁的是时候撤销semop(sem_id, &sem_op, 1);if(*p_shmat == -1) {//  解锁并退出sem_op.sem_op = 1;semop(sem_id, &sem_op, 1);break;}cout << "来自从进程的内容:p_shmat < " << *p_shmat << " > "<< endl;// 解锁sem_op.sem_op = 1; semop(sem_id, &sem_op, 1);//解除同步信号量sem_fp.sem_op = 1; // semop(sem_id, &sem_fp, 1);}// 解除映射shmdt(p_shmat);// 删除信号量semctl(sem_id, 0, IPC_RMID, nullptr);   //删除指定的共享内存区域shmctl(shm, IPC_RMID, nullptr);return 0;
}

从进程

#include <iostream>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "System.h"
#include <sys/sem.h>
#include <unistd.h>
using namespace std;// 从进程
int main()
{cout << "从进程" << endl;// 申请IPC设施的keykey_t key = ftok(IPC_PATH, IPC_PROJ );//申请信号量int sem_id = semget(key, 2, 0);// 获取主进程申请的 共享内存id号  大小是0，权限打开就可以int shm = shmget(key, 0 , 0);// 映射共享内存到用户空间int *p_shmat  =(int *)shmat(shm, nullptr, 0);//发送数据while(1){int input = 0;cout << "请输入：";cin >> input;// 上锁//  semop的第二个参数struct sembuf *sops成员struct sembuf sem_op ;sem_op.sem_op = -1; // 上锁sem_op.sem_num = 0;// 需要操作的信号量下标sem_op.sem_flg = SEM_UNDO; //死锁的是时候撤销semop(sem_id, &sem_op, 1);*p_shmat = input;if( *p_shmat == -1) {//  解锁并退出           sem_op.sem_op = 1;semop(sem_id, &sem_op, 1);break;}//  解锁sem_op.sem_op = 1;semop(sem_id, &sem_op, 1);// 通知主进程struct sembuf sem_fp ;sem_fp.sem_num = 1;sem_fp.sem_op = 1; // // 需要操作的信号量下标sem_fp.sem_flg = SEM_UNDO; //死锁的是时候撤销semop(sem_id, &sem_fp, 1);// 等待主进程处理sem_fp.sem_op = -1; // semop(sem_id, &sem_fp, 1);// usleep(5000);}// 解除映射shmdt(p_shmat);// 不需要删除共享内存，主进程负责return 0;
}

5.4 POSIX单个信号量

有名信号量：可以用于进程间或线程间 同步/互斥，在文件系统中有一个入口（有一个文件/inode），
信号量的对象（值）存在于内核中。既可以用于任意进程间，也可以用于线程间同步。
无名信号量：没有名字，无名信号量存在于内存中，无名信号量：基于内存的信号量

• 如果这段内存在一个 内核的共享内存中 进程可以访问，线程也可以访问—>既可以用于进程间的同

  步/互斥，也可以用于线程间同步/互斥。

• 如果这段内存在一个 进程的地址空间 此时只用于线程间（线程内部）同步/互斥

POSIX信号量：

• ``sem_t 描述 POSIX`信号量

5.4.1创建或打开一个POSIX信号量

• 有名信号量

 #include <fcntl.h>           /* For O_* constants */#include <sys/stat.h>        /* For mode constants */#include <semaphore.h>// 有名信号量
sem_t *sem_open(const char *name, int oflag);/*作用：创建或打开一个POSIX信号量@name：要创建或打开POSIX信号量在文件系统中的名字@oflag：1）打开：02）创建：O_CREAT*/sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value);/*作用创建或打开一个POSIX信号量@name：要创建或打开POSIX信号量在文件系统中的名字@oflag：1）打开：02）创建：O_CREAT@mode：创建权限位，两种方式：S_IRUSR 宏定义形式...0664    八进制形式@value：指定创建的有名信号量的初始值@return：成功返回一个sem_t的指针，指向POSIX有名信号量失败返回SEM_FAILED,同时errno被设置
*/

注意：POSIX的路径名只能在根目录下。

• 无名信号量
• 定义或分配一个无名信号量 sem_t
  • sem_t t1; // 无名信号量
  • sem_t *psem = malloc(sizeof(sem_t)); // 无名信号量

初始化无名信号量 sem_init

#include <semaphore.h>int sem_init(sem_t *sem, int pshared, unsigned int value);/*作用：初始化一个无名信号量@sem：sem_t 类型的指针表示需要初始化的无名信号量的空间首地址、@pshared：该无名信号量的共享方式0：表示进程内部线程共享      // 出现重复数据的打印，是有可能的，因为互斥锁不起作
用的sem指向地址进程内部空间1：不同进程的共享           // 出现重复数据的打印，是不可能的，因为互斥锁要起作
用sem指向地址内核共享内存区域@value：表示无名信号量的初始值。    @return:成功返回0，失败返回-1，同时errno被设置*/

5.4.2 POSIX信号量的P/V操作

• P操作

#include <semaphore.h>int sem_wait(sem_t *sem);/*作用：死等上锁@sem：指向一个POSIX信号量的空间地址需要上🔒的那个信号量@return：成功返回0，表示获取该信号量成功失败返回-1，表示该信号量获取失败
*/int sem_trywait(sem_t *sem);/*作用：尝试上锁,能够上锁就上锁，不能上锁就返回@sem：指向一个POSIX信号量的空间地址需要上🔒的那个信号量@return：成功返回0，表示获取该信号量成功失败返回-1，表示该信号量获取失败
*/int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);/*作用：限时上锁，超过绝对时间就返回@sem：指向一个POSIX信号量的空间地址需要上🔒的那个信号量@abs_timeout：绝对时间：绝对时间 = 当前时间 + 相对时间@return：成功返回0，表示获取该信号量成功失败返回-1，表示该信号量获取失败如：struct timespec ts;clock_gettime(CLOCK_REALTIME,&ts); // 获取绝对时间// 等待5s 30msts.tv_sec += 5;ts.tv_nsec += 30000000;if(ts.tv_nsec >= 1000000000){ts.tv_sec++;ts.tv_nsec-=1000000000;}int r = sem_timedwait(sem,&ts)*/

• V操作

#include <semaphore.h>int sem_post(sem_t *sem);/*
作用：
解锁
@sem：
需要解锁的信号量指针
@return：
成功返回0，失败返回-1，同时errno被设置
*/

5.4.3 POSIX有名信号量的关闭和删除操作

sem_close ：关闭一个POSIX 有名信号量
sem_unlink ：删除一个POSIX 有名信号量

#include <semaphore.h>int sem_close(sem_t *sem);/*@sem:需要关闭的有名信号量的指针@return：成功返回0，失败返回-1，同时errno被设置
*/int sem_unlink(const char *name);/*@name:需要删除的有名信号量的路径名@return：成功返回0，失败返回-1，同时errno被设置*/

5.4.4 POSIX无名信号量的销毁操作

sem_destroy ：销毁一个无名信号量

#include <semaphore.h>int sem_destroy(sem_t *sem);/*作用：销毁一个无名信号量@sem:需要销毁的无名信号量的指针@return：成功返回0，失败返回-1，同时errno被设置
*/

示例

主进程

6.exec函数簇

exec函数簇是一组函数，用于执行一个程序并替换当前进程的映像。这些函数属于unistd.h头文件中
定义的POSIX标准。当调用exec函数成功时，当前进程的代码段、数据段、堆栈等将被新程序的相应部
分替换，然后从新程序的入口点开始执行。进程ID不会改变，但进程的内存空间和属性将发生改变

6.1 exec函数API

execl函数：

• 作用：用新的程序替换当前进程的内存空间。

• 参数：

  • pathname：要执行的程序的路径。

  • arg 及后续可变参数：依次为新程序的命令行参数，以 NULL 指针结束。

execlp函数：

• 作用：与 execl 类似，但会在环境变量 PATH 中搜索可执行文件。
• 参数：
  • file：要执行的程序的文件名。
  • arg 及后续可变参数：同 execl。

execle函数：

• 作用：功能同 execl，但可以自己指定环境变量。
• 参数：
  • pathname：同 execl。
  • arg 及后续可变参数：同 execl。
  • envp[]：环境变量数组，以 NULL 指针结束。

execv函数：

• 作用：与 execl 类似，但参数以数组形式传递。

• 参数：

  • pathname：要执行的程序的路径。

  • argv[]：包含命令行参数的字符指 针数组，以 NULL 指针结束。

  • envp[]：环境变量数组，以 NULL 指针结束。

``execvp`函数：

• 作用：与 execv 类似，会在环境变量 PATH 中搜索可执行文件。
• 参数：
  • file：要执行的程序的文件名。
  • argv[]：同 execv。

execvpe函数：

• 作用：与 execvp 类似，但可以自己指定环境变量。

• 参数：

  • file：要执行的程序的文件名。
  • argv[]：同 execv。
  • senvp[]：环境变量数组，以 NULL 指针结束。

• 这些函数执行成功后不会返回，如果返回则表示执行失败