一、exec函数族介绍

• exec函数族的作用是根据指定的文件名找到可执行文件，并用它来取代调用进程的内容，换句话说，就是在调用进程内部执行一个可执行文件。
• exec函数族的函数执行成功后不会返回，因为调用进程的实体，包括代码段，数据段和堆栈等都已经被新的内容取代，只留下进程ID等一些表面上的信息仍保持原样，颇有些神似“三十六计”中的“金蚕脱壳”。看上去还是旧的躯壳，却已经注入了新的灵魂。只有调用失败了，它们才会返回-1，从原程序的调用点接着往下执行。

二、exec函数族作用图解

三、exec函数族

• int execl(const char *path, const char *arg, .../* (char *) NULL */);
• int execlp(const char *file, const char *arg, ... /* (char *) NULL */);
• int execle(const char *path, const char *arg, .../*, (char *) NULL, char * const envp[] */);
• int execv(const char *path, char *const argv[]);
• int execvp(const char *file, char *const argv[]);
• int execvpe(const char *file, char *const argv[], char *const envp[]);
• int execve(const char *filename, char *const argv[], char *const envp[]);

回顾

1 父进程调用 frok 函数 克隆出子进程 并且给他拷贝了空间 
2 两者操作互不影响 且 内存不能共享 。
继续冲 

exec 函数族

前面说的 父进程调用 frok 函数 克隆出子进程 并且给他拷贝了空间 
 两者操作互不影响 且 内存不能共享 。 
这样会导致浪费了空间内存 
如果用exec 就会节省空间 并且会多执行一个命令 或者更多命令 

exec 函数族的第一种函数说明和实验

path ：执行程序路径
arg ：执行程序参数 
第一个 arg：占位 
占位：占位符的意思 随意写就行了 最好和执行参数一样 为了好区分
后面的arg： 命令参数 多少都行 最后以NULL 结尾就行了

直接操作

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<sys/wait.h>

 int a=100;

int main()
{
     pid_t a;

     a=fork();

     if(a>0)
     {
                a+=200;
               printf("!!!A=%d\n",a);
             printf("father pid is %d\n",getpid());
          
     }
     else if(a==0)
     {
           a-=50;
         printf("*****a=%d\n",a);
         printf("child pid is %d ppid is %d \n",getpid(),getppid());
     }
       execl("/bin/ls","ls","-l","NULL");//多余命令 不占用空间 
        
     return 0;
}

如果只是实现一个命令参数

/bin/ls ：执行的程序路径   ls ：执行参数（可以不要 也可以随意 只是作为辅助作用）  -l 是命令参数 以 NULL结尾 
（execl 函数 的 绝对路径选到不能选为止）

多执行 hello.c 呢

第一

第二
gcc hello.c -o hello

./hello 运行可执行文件 
. 为命令 / 在当前目录下 找到 xxx文件 
 hello 为命令参数
  

怎么改呢 

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<sys/wait.h>

 int a=100;

int main()
{
     pid_t a;

     a=fork();

     if(a>0)
     {
                a+=200;
               printf("!!!A=%d\n",a);
             printf("father pid is %d\n",getpid());
          
     }
     else if(a==0)
     {
           a-=50;
         printf("*****a=%d\n",a);
         printf("child pid is %d ppid is %d \n",getpid(),getppid());
     }
     
     execl("/home/ycy/process/hello",“hello”，"hello",NULL);
     
     return 0;
}

因为 hello 就是命令参数了 所以占位符可以不写 写也可以 
写法 2   excel("/home/ycy/process/hello"，"hello",NULL);

exec 函数族的第二种函数说明和实验

和excel 少了一个参数而已 少了一个特定路径 

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<sys/wait.h>

 int a=100;

int main()
{
     pid_t a;

     a=fork();

     if(a>0)
     {
                a+=200;
               printf("!!!A=%d\n",a);
             printf("father pid is %d\n",getpid());
          
     }
     else if(a==0)
     {
           a-=50;
         printf("*****a=%d\n",a);
         printf("child pid is %d ppid is %d \n",getpid(),getppid());
     }
      excelp("ls","ls","-l","NULL");//多余命令 不占用空间 
     
     return 0;
}

引入

  创建子进程后，我们并不希望子进程执行父进程后续相同的内容，这时我们可以用exec函数族进行子进程的执行内容替换。

exec函数族

Linux下的exec函数族，是指6个以exec开头的函数。分别是

int execl(const char *path,const char *arg,...)
int execv(const char *path,char *cosnt arg[])
int execle(const char *path,const char *arg,...,char *const envp[])
int execve(const char *path,char *const argv[],char *const envp[])
int execlp(const char *file, const char *arg,...)
int execvp(const char *file, char *const argv[]);

复习：牢记const修饰的是谁？指针标记的优先级低于偏移符号[]。
const char *p：p是一个指针，指向常字符类型
char const *p：同上，const修饰的是*p
char * const p：p是一个常指针，指向字符类型。const修饰的是p
char *p[]：p是一个数组，其内容是字符指针
char (*p)[]：p是一个指针，指向的内容是字符数组（字符串）
char * const p[]：p是一个数组，数组的内容是常字符指针

我们介绍最常用的第一个程序：

int execl(const char *path,const char *arg,...)

执行原理

为什么说exec函数族可以使子进程执行不同的程序呢？
——“换核不换壳”：进程在调用exec函数时，进程用户空间的代码和数据空间的代码会完全被新的替代。也就是说原有的text和data会被替换掉，但是调用exec函数并不会产生新的进程，也不会改变PID。
  直白地讲，就是原有的箱子不变。但是调用exec函数后，其中原有的苹果被换成了梨。

使用场景

1. 进程认为自己不能再为系统和用户作出任何贡献时，就可以调用任何exec函数族让自己重生
2. 如果一个进程想要执行另一个程序，那么它就可以调用fork函数新建一个进程，然后调用任何一个exec函数使子进程重生。

我们依旧举一些例子：

//main.c文件
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>

int main(void)
{   
    //int execl(const char *pathname, const char *arg, ...
    //                   /* (char  *) NULL */);
    //第一个参数是要执行的执行文件的路径（包含文件名），第二个是要执行文件的文件名
    //之后的变长参数就是要带的参数。最后要以(char *)NULL作为最后一个参数
    pid_t pid;
    pid=fork();
    if(pid<0)
    {   
        printf("process create failed!");
    }   
    else if(pid == 0)
    {   
        printf("This is child process!");
        printf("PID=%d parent PID=%d\n",getpid(),getppid());
        execl("/home/czc/Desktop/LinuxExp/process/subproc","subproc",(char *)NULL);
        exit(1);
    }   
    else
    {   
        printf("This is parent process!");
        printf("PID=%d Its child PID=%d\n",getpid(),pid);
    }
    printf("This is father process remaining part!\n");
    return 0;
}

//./subproc.c文件
#include<stdio.h>
int main(void)
{
    printf("enter a new subProcess!\n");
    return 0;
}

调用main.c编译的可执行文件结果如下：

可以发现，父进程剩下的部分，子进程并没有执行。子进程在调用exec函数族后，就只执行subproc.c编译出来的可执行文件了。这里使用exit(1)的目的只是在exec调用失败后，也主动结束子进程。

命令即可执行文件

  之前已经提到，Linux下的命令就是可执行文件。那么同样地，我们在调用exec函数族时不仅可以使用我们自己编写的可执行文件，也可以调用系统命令（也就是系统自带的可执行文件）。我们对上面的C源文件稍作修改：

//main.c文件
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>

int main(void)
{   
    //int execl(const char *pathname, const char *arg, ...
    //                   /* (char  *) NULL */);
    //第一个参数是要执行的执行文件的路径（包含文件名），第二个是要执行文件的文件名
    //之后的变长参数就是要带的参数。最后要以(char *)NULL作为最后一个参数
    pid_t pid;
    pid=fork();
    if(pid<0)
    {   
        printf("process create failed!");
    }   
    else if(pid == 0)
    {   
        printf("This is child process!");
        printf("PID=%d parent PID=%d\n",getpid(),getppid());
        //ls命令在路径/bin/下
        execl("/bin/ls","ls","-al",(char *)NULL);
        exit(1);
    }   
    else
    {   
        printf("This is parent process!");
        printf("PID=%d Its child PID=%d\n",getpid(),pid);
    }
    printf("This is father process remaining part!\n");
    return 0;
}