如果我们使用fork()函数创建一个子进程，则该子进程几乎复制了父进程的全部内容，也就是说，子进程与父进程在执行同一个可执行程序。那么我们能否让子进程不执行父进程正在执行的程序呢？

exec函数族提供了让进程运行另一个程序的方法。exec函数族内的函数可以根据指定的文件名或目录名找到可执行程序，并加载新的可执行程序，替换掉旧的代码区、数据区、堆区、栈区与其他系统资源。这里的可执行程序既可以是二进制文件，也可以是脚本文件。在执行exec函数族函数后，除了该进程的进程号PID，其他内容都被替换了。

exec函数族有6个函数，这些函数的函数名、函数功能、函数参数列表有相似之处，我们在使用的过程中一定要仔细区分这些函数的区别避免混淆。有关exec函数族的更多使用方法内容请查阅man手册。

所需头文件：
#include<unistd.h>

函数原型：
int execl(const char *path, const char *arg,…)
int execlp(const char *file, const char *arg,…)
int execle(const char *path, const char *arg,…, char *const envp[])
int execv(const char *path, char *const argv[])
int execvp(const char *file, char *const argv[])
int execve(const char *path, char *const argv[], char *const envp[])

函数参数：
path：文件路径，使用该参数需要提供完整的文件路径
file：文件名，使用该参数无需提供完整的文件路径，终端会自动根据$PATH的值查找文件路径
arg：以逐个列举方式传递参数
argv：以指针数组方式传递参数
envp：环境变量数组

返回值：
-1（通常情况下无返回值，当函数调用出错才有返回值-1）

这6个函数的函数功能类似，但是在使用语法规则上有细微区别。我们可以看出，其实exec函数族的函数都是exec+后缀来命名的，具体的区别如下：

区别1：参数传递方式（函数名含有l还是v）

• 若函数名内含有字母’l’（表示单词list），则表示该函数是以逐个列举的方式传参，每个成员使用逗号分隔，其类型为const char *arg，成员参数列表使用NULL结尾
• 若函数名内含有字母’v’（表示单词vector），则表示该函数是以指针数组的方式传参，其类型为char *const argv[]，命令参数列表使用NULL结尾

区别2：查找可执行文件方式（函数名是否有p）

• 若函数名内没有字母’p’，则形参为path，表示我们在调用该函数时需要提供可执行程序的完整路径信息
• 若函数名内含有字母’p’，则形参为file，表示我们在调用该函数时只需给出文件名，系统会自动按照环境变量$PATH的内容来寻找可执行程序

区别3：是否指定环境变量（函数名是否有e）

• 若函数名内没有字母’e’，则使用系统当前环境变量
• 若函数名内含有字母’e’（表示单词environment），则可以通过形参envp[]传入当前进程使用的环境变量

这6个exec函数族的函数，execve()函数属于系统调用函数，其余5个函数属于库函数。

1. 进程程序替换是什么

我们直到一个进程被创建出来，OS会给它分配进程PCB，mm_struct,页表等信息，同时会将程序的代码和数据加载到物理内存是吧；
而进程程序替换就是：正在执行的进程本身的pcb,mm_struct，页表等信息不会发生改变，仅仅把一个新的程序代码和数据替换了原来进程的代码和数据；这就是进程程序的替换；

---

如下图：我们有个进程，在执行中，如果发生进程程序替换，只不过事把该进程的代码和数据从磁盘加载到了物理内存罢了，其他信息不会变化；

---

进程程序替换并不会创建新的进程，它只会加载程序的代码和数据，去替换原来的进程！！！

---

2. 进程替换函数–exec族

#include <unistd.h>` //exec函数族的头文件
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);

1. 这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回；
2. 如果调用出错则返回-1；
3. 所以exec函数只有出错的返回值而没有成功的返回值；

---

这些函数原型看起来很容易混,但只要掌握了规律就很好记。

l(list) : 表示参数采用列表；
v(vector) : 参数用数组；
p(path) : 有p自动搜索环境变量PATH；
e(env) : 表示自己维护环境变量；

---

---

最简单的程序替换程序：

int main()
{
  execl("/usr/bin/ls","ls","-a","-l",NULL); //程序替换函数
  printf("这段代码是在execl执行成功是不会执行的\n");
  return 0;
}

---

而我们程序替换的本质：

---

而我们的程序替换函数，通常不父进程去执行，而是交给子进程执行，因为这也子进程可以做它的事，父进程也可以做自己的事，由于进程之间的独立性，即使子进程去执行execl函数时候，替换的也是子进程的代码和数据，而父进程的代码和数据是不会被影响的；

---

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/wait.h>

int main()
{
  pid_t pid = fork();

  if(pid == 0){
    //child process 
    execl("/usr/bin/ls","ls","-a","-l",NULL);
    //退出子进程
    exit(0);
  }
  //父进程执行的代码
  wait(NULL);
  printf("i am father[%d] ,do my thing ,不会被子进程的[%d]execl函数影响\n",getpid(),pid);
  return 0;
}

---

请问：发生了子进程的程序替换，此时：父子进程的代码还是共享的码？

当然不会共享了，此时发生了写时拷贝，也就是会拷贝出一份代码和数据出来，然后子进程再被它的execl函数进行函数替换；

---

3. execl函数的使用

---

4. execv函数的使用

execv和execl也是没啥区别，只不过execv叭execl的以列表形式的传参，变成了以数组形式的传参；

---

int main()
{
  if(fork() == 0){
 // execl("/usr/bin/ls","ls","-a","-l",NULL);
 	//等价下面的execv("/usr/bin/ls",argv); 
    char*const argv[] = {
      "ls",
      "-a",
      "-l",
      NULL 
    };
    execv("/usr/bin/ls",argv); 
    exit(1);
  }
  int waitRet = waitpid(-1,NULL,0); //阻塞等待所有子进程结束
  if(waitRet< 0){
    perror("wait error\n");
  }
  printf("parent wait child success\n");

  return 0;
}

---

5. execlp函数的使用

execlp和execl的区别在于，execlp在第一个参数时候，不需要全路径，只需要写上执行命令的文件名即可，表示你需要执行谁，往后的参数也就是和execl的传参一样；

---

#include<stdio.h>
#include<unistd.h>//使用fork,exec函数
#include<sys/wait.h>//使用waitpid
#include<stdlib.h> //使用exit的头文件
int main()
{
  if(fork() == 0){
 // execl("/usr/bin/ls","ls","-a","-l",NULL);
    execlp("ls","ls","-a","-l",NULL); //等价上面的execl()
	//虽然这里的第一个参数和第二个参数都一样，但是含义不一样；
	//第一个参数表示iexeclp函数要执行命令的路径文件名，
	//第二个参数表示execlp在命令行上如何执行该命令
    exit(1);
  }
  int waitRet = waitpid(-1,NULL,0); //阻塞等待所有子进程结束
  if(waitRet< 0){
    perror("wait error\n");
  }
  printf("parent wait child success\n");

  return 0;
}

---

6. execvp函数的使用

这个函数execvp和execv的区别在于。execvp第一个传参时候，不需要给出要执行命令的绝对路径，只需要给出要执行命令的文件名即可；

---

#include<stdio.h>
#include<unistd.h>//使用fork,exec函数
#include<sys/wait.h>//使用waitpid
#include<stdlib.h> //使用exit的头文件
int main()
{
  if(fork() == 0){
 // execl("/usr/bin/ls","ls","-a","-l",NULL);
    //execlp("ls","ls","-a","-l",NULL); //等价上面的execl()
    char* const argv[] = {
      "ls",
      "-a",
      "-l",
      NULL 
    };
    //execv("/usr/bin/ls",argv);
    execvp("ls",argv);//等价上面的execv()

    exit(1);
  }
  int waitRet = waitpid(-1,NULL,0); //阻塞等待所有子进程结束
  if(waitRet< 0){
    perror("wait error\n");
  }
  printf("parent wait child success\n");

  return 0;
}

---

---

7. 验证exec函数族执行自己写的程序

1. makefile 文件，编译链接生成myload和myexe两个文件；
2. 这两个文件的作用是：myload加载myexe的程序，验证execv函数执行自己写的程序是否可以；

.PHONY:all
all:myload myexe # 该目标文件all不会被生成，是因为没有依赖方法

myload:myload.c
	gcc $^ -o $@
myexe:myexe.c
	gcc $^ -o $@

.PHONY:clean
clean:
	rm -rf myload myexe

---

myexe.c文件的内容：

#include<stdio.h>

int main(){
  printf("i am myexe\n");
  return 0;
}

myload.c文件

#include<stdio.h>
#include<unistd.h>//使用fork,exec函数
#include<sys/wait.h>//使用waitpid
#include<stdlib.h> //使用exit的头文件
int main()
{
  if(fork() == 0){
    execl("./myexe","./myexe",NULL);
    exit(1);
  }
  int waitRet = waitpid(-1,NULL,0); //阻塞等待所有子进程结束
  if(waitRet< 0){
    perror("wait error\n");
  }
  printf("parent wait child success\n");

  return 0;
}

---

测试结果：执行myoad，成功加载了myexe程序；

8. execle 和 execve函数的使用

这个函数只是比execl多了一个e,表示最后一个参数需要给execle传入自定义的环境变量数组；
它的使用情况是：假如你要给一个你需要执行新的程序，加载一些自定义的环境变量给新的程序时候，你可以使用该函数；

---

测试：
myexe.c文件：打印环境变量的值，这个文件假如自己执行自己的话，那么就打印默认的环境变量；
假如其他文件使用execle传参给myexe.c环境变量，myexe.c就会执行该execle传过来的环境变量；

---

#include<stdio.h>

int main(){
  extern char** environ; //系统提供的环境变量指针，指向环境变量的指针数组
  int i = 0;
  for(;environ[i];i++){
    printf("%s\n",environ[i]);
  }
  return 0;
}

---

myload.c文件：使用execle函数，给该函数传递环境变量；使得myexe可执行程序可以获得该myload.c传递过去的环境变量；

#include<stdio.h>
#include<unistd.h>//使用fork,exec函数
#include<sys/wait.h>//使用waitpid
#include<stdlib.h> //使用exit的头文件
int main()
{
  if(fork() == 0){
    char* const env[] = {
      "MYENV0=123",
      "MYENV1=456",
      "MYENV2=789",
      NULL 
    };
     //char* const argv[] = {
    //	 	"./myexe",
   //  		NULL
    //};
    execle("./myexe","./myexe",NULL,env);
    //execlv("./myexe",argv,,env); //等价上execle的方式
    exit(1);
  }
  int waitRet = waitpid(-1,NULL,0); //阻塞等待所有子进程结束
  if(waitRet< 0){
    perror("wait error\n");
  }
  printf("parent wait child success\n");

  return 0;
}

---

测试结果：

---

9. exec函数族使用的总结

1. 有了exec函数族我们就可以用它来调用任何程序，也就是说，你还可以在C/C++，可以调用其他任何语言，比如python，Java等程序；
2. 这些exec函数的接口函数本质是没有任何差别的，只是参数选项不同罢了；
3. 为什么有那么多种接口，本质满足不同引用场景而已；
4. 这些函数之间的调用关系，本质都会调用系统调用函数execve；
   

---

fork()函数用于创建一个子进程，该子进程几乎复制了父进程的全部内容。我们能否让子进程执行一个新的程序呢？exec函数族就提供了一个在进程中执行另一个程序的方法。它可以根据指定的文件名或目录名找到可执行文件，并用他来取代当前进程的数据段、代码段和堆栈段。在执行完后，当前进程除了进程号外，其他内容都被替换。

头文件：#include <unistd.h>

函数原型：

int execl(const char*path, const char *arg, ...); //1. 查找方式：完整的文件目录路径；2. 参数传递方式：逐个列举（list）

int execv(const char*path, const char *const arg[]); //2. 参数传递方式：指针数组传递（vertor）

int execle(const char*path, const char *arg, ..., char *const envp[]); //3. 使用默认的环境变量（environment），在envp[]中指定当前进程使用的环境变量

int execve(const char*path, const char *const arg[], char *const envp[]);

int execlp(const char*file, const char *arg, ...); //1. 查找方式：文件名

int execvp(const char*file, const char *const arg[]);

exec函数名对应名称：

前四位：exec

第五位

l：参数传递为逐个列举方式

v：参数传递为构造指针数组的方式

第六位：

e：可传递新进程环境变量

p：可执行文件查找方式为文件名

函数返回值：-1：出错

如何使用文件名的方式查找可执行文件，同时使用参数列表的方式

这里使用的函数是execlp()

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
int main()
{
    pid_t pid=fork();
    if(pid==0)
    {
        if((ret=execlp("ps","ps","-ef",NULL))<0) //相当于调用了“ps -ef”命令
    {
        printf("execlp error\n");
    }
}

 使用完整的文件目录来查找对应的可执行文件。

这里使用的函数是execl()

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
    if(fork()==0)
    {
        if(execl("/bin/ps","ps","-ef",NNULL)<0); //目录必须以“/”开头，否则将视其为文件名
        {
            printf("execl error\n");
        }
    }
}

利用execle()将环境变量添加到新建的子进程中

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    char *envp[]={"PATH=/tmp","USER=harry",NULL}; //命令行参数列表，必须以NULL结尾
    if(fork()==0)
    {
        if(execle("/usr/bin/env","env",NULL,envp)<0) //env是查看当前进程环境变量的命令
        {
            printf("execle error\n");
        }
    }
}

 使用execve()函数，通过构造指针数组的方式来传递参数

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    char *arg[]={"env",NULL};
    char *envp[]={"PATH=/tmp","USER=harry",NULL};
    if(fork())
    {
        if(execve("/usr/bin/env",arg,envp)<0)
        {
            printf("execve error\n");
        }
    }
}