linux编程，关于main函数的参数argv

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了linux编程，关于main函数的参数argv相关的知识，希望对你有一定的参考价值。

int main(int argc,char*argv[])
char buf[20];
buf=argv[1];

这段程序不是把argv[1]的地址赋给了buf么？为什么编译器提示类型不匹配，但我也看到别人的程序能通过啊。

不可能通过的了，buf是数组地址，你把一个指针赋给它，是不会成功的，编译报警也是正确的。
有两种改法：
1）改定义 char* buf;
2）改赋值方式，strncpy(buf, argv[1], sizeof(buf)); 参考技术A #include <stdio.h>
#include <string.h>
int main(int argc,char *argv[])

char buf[50]=NULL;
//buf=argv[1];//字符串是不能这样直接赋值的
strcpy(buf,argv[0]);//用函数来拷一下...
printf("%s\n",buf);
return 0;
本回答被提问者和网友采纳 参考技术B 在头文件中添加
#include<string.h>

在代码中修改 strcpy(buf,argv[i]);

（49）LINUX应用编程和网络编程之四 Linux进程全解

补充：
1、  C程序的执行过程：
C编译器调用链接器，链接器设置可执行程序文件的启动起始地址（启动例程），启动例程获得内核传递来的
命令行参数和环境变量值，为调用main函数做准备。【实际上该启动例程常用汇编语言编写】，如果将启动例程换做C语言就是：exit(main(argc,argv));
main(int argc,char *argv[],char *engv[]);argv为指向参数的各个指针所构成的数组。
2、exit做一些清理处理（标准IO库的清理关闭操作为所有打开的流调用fclose函数）再进入内核，而_exit和_EXIT直接进入内核中。
main函数中返回一个整型值与用该值调用exit是等价的。   使用命令"echo $?"来打印终止状态.
注意：内核使程序执行起来的唯一方法是调用一个exec函数。其实各个exec函数族的各个函数参数意思都差不多，无论是哪个exec函数，都是将可执行程序的路径，命令行参数，和环境变量3个参数传递给可执行程序的main()函数;
代码示例：
#include<stdio.h>
#include<stdlib.h>
int main(int argc,char *argv[])
{
    int i=0;
    printf("hello!\\n");
    for(i=0;i<argc;i++)
    {
        printf("argv[%d]=%s\\n",i,argv[i]);
    }
    char *p=NULL;
    p=getenv("USER");   //getenv函数返回的是一个char *类型的指针
    printf("p=%s\\n",p);
    exit(0);
}
3、环境表：环境表也是一个字符指针数组，每个程序都会接收到一张环境表。每个指针数组包含一个以null结束的C字符串的地址。
4、所有进程都具有唯一的进程ID号码，ID为0的进程是调度进程，即交换进程；该进程是内核的一部分，即系统进程，所有子进程的父ID不可能是0；init进程1是所有孤儿进程的父进程,它由内核调用，但不属于内核，一般做一些初始化的工作。进程ID2是页守护进程，此进程负责支持虚拟存储系统的分页操作。
1)pid_t getpid(void);//该进程ID号码
2)pid_t getppid(void);//当前进程的父ID号
5、fork函数的返回值有两个，一个返回给子进程，一个返回给父进程；其中返回给子进程的ID号是0，返回给父进程的ID号是新创建的子进程ID，因为父进程可以有很多个子进程，要通过这个ID号来区分不同的子进程。
注意的几点：
1）子进程对变量所做的改变并不影响父进程中该变量的值。
2）fork后父进程中所有打开的文件描述符都会被复制到子进程中。
3）fork的用法中在网络服务进程中，父进程等待客户端的服务请求，当这种请求到达时，父进程调用fork，使子进程处理此请求，父进程则继续等待下一个服务请求到达。
wait&waitpid
exec族 ：被内核调用
进程状态（运行、等待、停止、就绪、僵尸）
进程关系（进程组和会话）
守护进程
进程间通信
-----------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.1.程序的开始和结束
3.4.1.1、main函数由谁调用
(1)编译链接时的引导代码。操作系统下的应用程序其实在main执行前也需要先执行一段引导代码(构建执行环境)才能去执行main，我们写应用程序时不用考虑引导代码的问题，编译链接时（准确说是链接时）由链接器将编译器中事先准备好的引导代码给连接进去和我们的应用程序一起构成最终的可执行程序。
(2)运行时的加载器。加载器是操作系统中的程序，当我们去执行一个程序时（譬如./a.out，譬如代码中用exec族函数来运行）加载器负责将这个程序加载到内存中去执行这个程序。
(3)程序在编译连接时用链接器，运行时用加载器，这两个东西对程序运行原理非常重要。
(4)argc和argv的传参如何实现
 
3.4.1.2、程序如何结束
(1)正常终止：return、exit、_exit /_EXIT
(2)非正常终止：自己或他人发信号(类似于电话标志)终止进程，信号也是有优先级的
3.4.1.3、atexit向操作系统注册进程终止处理函数(即main执行结束后调用的函数)
注意：按照ISO C的规定，一个进程可以登记多达32个函数，这些函数将由exit自动调用。atexit（）注册的函数类型应为不接受任何参数的void函数,exit调用这些注册函数的顺序与它们 登记时候的顺序相反(压栈过程)。同一个函数如若登记多次，则也会被调用多次。
【函数原型：】
#include <stdlib.h>
int atexit(void (*function)(void));
(1)实验演示   
代码示例：
#include<stdio.h>
#include<stdlib.h>
void func1(void)
{
    printf("func1\\n");
}
void func2(void)
{
    printf("func2\\n");
}
int main(int argc,char  **argv)
{
    printf("hello world \\n");
    atexit(func1);
    atexit(func2);
    return 0;  //效果等同于exit(0);
    //_exit(0);和_Exit(0);不能显示    atexit();的内容，因为它立即返回给内核态
}
 
(2)atexit注册多个进程终止处理函数，先注册的后执行（先进后出，和栈一样）因为注册一个，就把atexit函数中的参数--函数指针进行压栈处理。
(3)return、exit和_exit的区别：return和exit效果一样，都是会执行进程终止处理函数，但是用_exit终止进程时并不执行atexit注册的进程终止处理函数。
 
 
补充：我们通常认为C语言的起始函数是main函数，实质上一个程序的启动函数并不一定是main函数，这个可以采用链接器来设置，但是gcc中默认main就是C语言的入口函数，在main函数启动之前，内核会调用一个特殊的启动例程，这个启动例程从内核中【取得命令行参数值和环境变量值】，为调用main函数做好准备，因此对应用程序而言main函数并不是起始，但是对应C语言而言，main函数就是入口地址，其他的由链接器帮助我们完成，实际上mian函数的执行是使用了exec函数，这是一个函数族，这也是内核执行一个程序的唯一方法，这在进程控制部分将进行分析。
 
记得在面试题中有一道关于在main函数退出之后，是否还可以执行程序的问题，这时候就要使用到前面提到的atexit函数。
#include<stdlib.h>
int atexit(void(*func)(void));
其中，atexit的参数是一个函数地址（或者说是一个函数指针），当调用此函数（指的是atexit的参数 ）时无须传递任何参数，该函数也不能返回值，atexit函数称为终止处理程序注册程序，注册完成以后，当函数终止是exit()函数会主动的调用前面注册的各个函数，但是exit函数调用这些函数的顺序于这些函数登记的顺序是相反的，我认为这实质上是参数压栈造成的，参数由于压栈顺序而先入后出。同时如果一个函数被多次登记，那么该函数也将多次的执行。
我们知道exit是在main函数调用结束以后调用，因此这些函数的执行肯定在main函数之后，这也是上面面试题的解决方法。即采用atexit函数登记相关的执行函数即可。
在exit函数的介绍中我们知道，exit()和_exit()以及_Exit()函数的本质区别是是否立即进入内核，_exit()以及_Exit()函数都是在调用后【立即进入内核】，而不会执行一些清理处理(就比如说地震的时候我们直接非正常下班)，但是exit()则会执行一些清理处理，这也是为什么会存在atexit()函数的原因，因为exit()函数需要执行清理处理，需要执行一系列的操作，这些终止处理函数实际上就是完成各种所谓的清除操作的实际执行体。atexit函数的定义也给了程序员一种运用exit执行一些清除操作的方法，比如有一些程序需要额外的操作，具体的清除操作可以采用这种方法对特殊操作进行清除等。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.2.进程环境
3.4.2.1、环境变量(可以理解为操作系统中的全局变量)
(1)export命令查看环境变量
(2)进程环境表介绍.每一个进程中都有一份所有环境变量(export)构成的一个表格，也就是说我们当前进程中可以直接使用这些环境变量。进程环境表其实是一个字符串数组，用environ变量指向它。
(3)程序中通过【environ全局变量】使用环境变量，只需要声明就可以了，extern char **environ //二重指针
代码示例：打印出系统中的所有环境变量
#include<stdio.h>
int main(void)
{
    extern char **environ;
    int i=0;
    while(NULL != environ[i])   
    {
        printf("%s\\n",environ[i]);
        i++;
    }
    return 0;
}
(4)我们写的程序中可以无条件直接使用系统中的环境变量，所以一旦程序中用到了环境变量那么程序就和操作系统环境有关了.
(5)在一个应用程序中获取指定环境变量函数getenv(值得注意的是我们setenv或者是getenv的时候更改的是当前这个进程中的一份环境变量，而不是更改的操作系统中的那一份环境变量)
uboot中的环境变量移植了linux内核中的环境变量的设置方法。
3.4.2.2、进程运行的虚拟地址空间
(1)操作系统中每个进程在独立地址空间中运行
(2)每个进程的逻辑地址空间均为4GB（32位系统）
(3)每个进程认为4G的内存空间，0-1G为OS，1-4G为应用
(4)虚拟地址到物理地址空间的映射
(5)意义。进程隔离，安全性，提供多进程同时运行
我们写程序不用指定链接脚本的原因就是已经有了一个默认的链接脚本，这个默认的链接脚本指定我们应用程序的虚拟地址从0地址开始运行。
像单片机中用的RTOS，用的物理地址，需要重新烧录和编译。
-----------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.3.进程的正式引入
3.4.3.1、什么是进程
(1)动态过程而不是静态实物
(2)进程就是程序的一次运行过程，一个静态的可执行程序a.out的一次运行过程（./a.out去运行到结束）就是一个进程。
(3)进程控制块PCB（process control block），内核中专门用来管理一个进程的数据结构。
也就是说对于我们每一个进程，操作系统会分配给我们一个PCB结构体，这个结构体中包含了这个进程的各种信息和元素。
3.4.3.2、进程ID(唯一来标识一个进程)
(1)getpid（获得当前进程的ID）、getppid(获得父进程ID)、getuid(获取当前进程的用户ID，比如root用户或是普通用户)、geteuid、getgid(获得当前进程的组ID)、getegid这些函数来获得当前进程的ID。
(2)实际用户ID和有效用户ID区别（可百度）
实际组ID和有效组ID。
【  #include <sys/types.h>
       #include <unistd.h>
       pid_t getpid(void);    //获得当前进程的ID
       pid_t getppid(void);   //获得父进程ID
】
当我们执行一个进程后，操作系统分配的进程ID只能使用一次，就算再次执行这个进程，操作系统分配的进程ID也不会跟之前的进程重复了，而是一直往后走。
 
(3)linux中使用ps  -aux命令来打印操作系统中所有的进程。
 
3.4.3.3、多进程调度(调度就是指在单位时间里怎么分配、安排多个进程之间的运行次序)原理
(1)操作系统同时运行多个进程(裸机程序就可以当作是只运行一次的操作系统，是单进程的操作系统)
(2)宏观上的并行和微观上的串行
(3)实际上现代操作系统最小的【调度单元】是进程，执行的最小单位是线程。
(例子：服务员（CPU）在不停桌间（进程）的上菜（执行线程）)
 
3.4.4.fork创建子进程
操作系统每次重新创建一个进程都是需要一定成本的，因为对于PCB这个结构体块来说需要占有一定的内存
3.4.4.1、为什么要创建子进程
(1)每一次程序的运行都需要一个进程
(2)多进程实现宏观上的并行
 
 
如果完全建立一个全新的进程出来是需要占用很多资源的，比如时间资源；但是从一个老进程那里直接copy出一个新进程，并且在这个新进程中进行更改某些模块，会节约很多资源，效率也会高很多。 这就是建立一个新的进程的主要意义。
3.4.4.2、fork的内部原理
 #include <unistd.h>
 pid_t fork(void); 
(1)进程的分裂生长模式。如果操作系统需要一个新进程来运行一个程序，那么操作系统会用一个现有的进程来复制生成一个新进程。【老进程叫父进程，复制生成的新进程叫子进程。】
(2)fork的演示
(3)【fork函数调用一次会返回2次】，返回值等于0的就是子进程，而返回值大于0（实际上是子进程的进程ID号）的就是父进程。因为fork函数就是去创造进程的，自然要返回两次。(就像生孩子一样，进去一个人，出来两个人，fork调用后就会出现两个进程，通过其返回值来判断哪个是父进程，哪个是子进程
父进程和子进程里面有完全一样的代码，同时被操作系统调度运行，也就是一个程序中fork后拥有两个进程，一个是程
序本身作为父进程，一个是fork创建的子进程。
代码示例：
 #include <unistd.h>
 #include <stdio.h>
 int main(void)
 {
     pid_t p1;
     p1=fork();
     if(p1==0)
     {
        printf("这里是子进程，ID是：%d\\n",getpid());
        printf("在子进程中，父进程ID是：%d\\n",getppid());
     }
     if(p1>0)
     {
         printf("这里是父进程，ID是：%d\\n",getpid());
         printf("在父进程中，子进程ID是：%d\\n",p1);
     }
          return 0;
 }
 
(4)典型的使用fork的方法：使用fork后然后用if判断返回值，并且返回值大于0时就是父进程，等于0时就是子进程。
(5)fork的返回值在子进程中等于0，在父进程中等于本次fork创建的子进程的进程ID。
 
3.4.4.3、关于子进程
(1)子进程和父进程的关系（相互独立的）
(2)子进程有自己独立的PCB(由父进程那里复制而来，但是后来有改动，子进程被内核同等调度)
(3)子进程被内核同等调度
 
 
3.4.5.父子进程对文件的操作
3.4.5.1、子进程继承父进程中打开的文件
(1)上下文：父进程先open打开一个文件得到fd，然后在fork创建子进程。之后在父子进程中各自write向fd中写入内容
(2)测试结论是：接续写。实际上本质原因是父子进程之间的fd对应的文件指针是彼此关联的（很像O_APPEND标志后的样子）
(3)实际测试时有时候会看到只有一个，有点像分别写。但是实际不是。原因是父进程写完后直接把文件关闭了，关闭后子进程就写不进去内容了。
代码测试：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#define NAME "1.txt"
int main()
{
    char a[]="aa";
    char b[]="bb";
    int fd=-1;
    pid_t pid;
    fd=open(NAME,O_RDWR);
    if(fd<0)
    {
        perror("open");
        return -1;
    }
    pid=fork();
    if(pid==0)   //子进程
    {
        write(fd,&a,2);
     }
    if(pid>0)    //父进程
    {
            write(fd,&b,2);
      }
    if(pid<0)     //fork出错
    {
        perror("fork");
        return -1;
    }
    return 0;
}
 
3.4.5.2、父子进程各自独立打开同一文件实现共享
(1)父进程open打开1.txt然后写入，子进程打开1.txt然后写入，结论是：【分别写】。原因是父子进程分离后才各自打开的1.txt，这时候这两个进程的PCB已经独立了，文件表也独立了，因此2次读写是完全独立的。
(2)open时使用O_APPEND标志看看会如何？实际测试结果标明O_APPEND标志可以把父子进程各自独立打开的fd的文件指针给关联起来，实现接续写。
代码示例：
#include<stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#define   NAME     "1.txt"
int main(void)
{
    char buf[100]="linux program";
    pid_t pid;
    int fd=-1;
    ssize_t  ret;
    pid=fork();
if(pid>0)          //父进程
{
    fd=open(NAME,O_RDWR | O_APPEND);
    if(fd==-1)
    {
        perror("open");
        _exit(-1);
    }
     ret= write(fd,&buf,sizeof(buf));
     if(ret == -1)
     {
         perror("write");
         _exit(-1);
     }
}
 
 
 
       if(pid==0)       //子进程
{
    fd=open(NAME,O_RDWR | O_APPEND);
    if(fd==-1)
    {
        perror("open");
        _exit(-1);
    }
     ret= write(fd,&buf,sizeof(buf));
     if(ret == -1)
     {
         perror("write");
         _exit(-1);
     }
}
 
      if(pid<0) 
      {
          perror("fork");
          _exit(-1);
      }
      close(fd);
return 0;
}
 
3.4.5.3、总结
(1)父子进程间终究多了一些牵绊
(2)父进程在没有fork之前自己做的事情对子进程有很大影响，但是父进程fork之后在自己的if里做的事情就对子进程没有影响了。本质原因就是因为fork内部实际上已经复制父进程的PCB生成了一个新的子进程，并且fork返回时子进程已经完全和父进程脱离并且独立被OS调度执行。
(2)子进程最终目的是要独立去运行另外的程序
(有点类似于父子分家)
-----------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.6.进程的诞生和消亡
3.4.6.1、进程的诞生
(1)进程0和进程1(在内核态由进程0 fork出来的进程1也就是init进程)，从进程2才开始进入用户态。
进程0属于内核态，进程1不属于内核态，但是它被内核态调用，是所有孤儿进程的父进程，从进程2开始才是进入用户态。
(2)fork
(3)vfork 
vfork和fork的主要区别是vfork能够保证子进程先运行。
3.4.6.2、进程的消亡
(1)正常终止和异常终止
(2)进程在运行时需要消耗系统资源（内存、IO），进程终止时理应完全释放这些资源（如果进程消亡后仍然没有释放相应资源则这些资源就丢失了）
(3)linux系统设计时规定：每一个进程退出时，操作系统会【自动回收】这个进程涉及到的所有的资源（譬如malloc申请的内容没有free时，当前进程结束时这个内存会被释放，譬如open打开的文件没有close的在程序终止时也会被关闭）。但是操作系统并没有回收干净，只是回收了这个进程工作时消耗的内存和IO，而并没有回收这个进程本身占用的内存（8KB，主要是task_struct(进程描述结构体)和栈内存）
(4)因为进程本身的8KB内存操作系统不能回收需要别人来辅助回收，因此我们每个进程都需要一个帮助它收尸的人，这个人就是这个进程的父进程。
 
3.4.6.3、僵尸进程
(1)子进程先于父进程结束。子进程结束后父进程此时并不一定立即就能帮子进程“收尸”，在这一段（子进程已经结束且父进程尚未帮其收尸）子进程就被成为僵尸进程。
(2)子进程除task_struct和栈外其余内存空间皆已被操作系统清理
(3)父进程可以使用wait函数或waitpid函数以显式回收【子进程的剩余待回收内存资源】并且【获取子进程退出状态。看子进程是否是正常退出的】
(4)父进程也可以不使用wait或者waitpid回收子进程，此时父进程结束时一样会回收子进程的剩余待回收内存资源。（这样设计是为了防止父进程忘记显式调用wait/waitpid来回收子进程从而造成内存泄漏）
3.4.6.4、孤儿进程
(1)父进程先于子进程结束，子进程成为一个孤儿进程。
(2)linux系统规定：所有的孤儿进程都自动成为一个特殊进程（进程1，也就是init进程）的子进程。
 
 
3.4.7.父进程调用wait函数回收子进程
3.4.7.1、wait的工作原理
(1)子进程结束时，【操作系统】就向其父进程发送SIGCHILD信号 来提醒父进程去回收
(2)父进程调用wait函数后阻塞，阻塞就是为了随时循环监听、等待操作系统发给的信号
(3)父进程收到信号后被SIGCHILD信号唤醒然后去回收僵尸子进程
(4)父子进程之间是异步的（就是说父子进程之间发生什么事是互相不知道的），SIGCHILD信号机制就是为了解决父子进程之间的【异步通信】问题，让父进程可以及时的去回收僵尸子进程。
(5)若父进程没有任何子进程则wait函数返回错误
3.4.7.2、wait实战编程
函数原型：
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
 
(1)wait的参数status。status用来返回子进程结束时的状态，父进程通过wait得到status后就可以知道子进程的一些结束状态信息。
 
(2)wait的返回值pid_t，这个返回值就是本次wait回收的子进程的PID。当前父进程有可能有多个子进程，wait函数阻塞直到其中一个子进程结束wait就会返回，wait的返回值就可以用来判断到底是哪一个子进程本次被回收了。
对wait做个总结：wait主要是用来回收子进程资源，回收同时还可以得知被回收子进程的【pid和退出状态】。
(3)fork后wait回收实例
 
(4)WIFEXITED、WIFSIGNALED、WEXITSTATUS这几个函数宏用来获取子进程的退出状态。
1、WIFEXITED宏用来判断子进程是否正常终止（return、exit、_exit退出）
2、WIFSIGNALED宏用来判断子进程是否非正常终止（被信号所终止）
3、WEXITSTATUS宏用来得到正常终止情况下的进程返回值的。
代码示例：
#include<stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void)
{
       pid_t pid,ret_pid;  //分别定义fork返回值和wait回收后获得的子进程ID
       int status;
       pid = fork();
       if(pid>0)         //父进程
       {
              ret_pid= wait(&status);
              printf("父进程回收的子进程的PID是：%d\\n",ret_pid);
              if(WIFEXITED(status))
              {
              printf("子进程是正常终止\\n");
              printf("子进程正常终止的返回值是:%d\\n",WEXITSTATUS(status));//得到正常终止情况下的进程返回值的
              }
               printf("子进程是否非正常终止：%d\\n",WIFSIGNALED(status));
        }
       if(pid==0)        //子进程
       {
         printf("子进程，pid是%d\\n",getpid());
         return 234;
         sleep(1);
        }   
         if(pid<0)
         {
             perror("fork");
             _exit(-1);
         }             
    return 0;
}       
3.4.8.waitpid介绍
3.4.8.1、waitpid和wait差别
(1)基本功能一样，都是用来回收子进程
(2)waitpid可以回收指定PID的子进程
(3)waitpid可以阻塞式或非阻塞式两种工作模式 ，而wait函数只能够阻塞式的去回收。
3.4.8.2、waitpid原型介绍
(1)参数
(2)返回值
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);
 
3.4.8.3、代码实例
(1)使用waitpid实现wait的效果
ret = waitpid(-1, &status, 0);      负1表示不等待某个特定PID的子进程而是回收任意一个子进程，0表示用默认的方式（阻塞式）来进行等待，返回值ret是本次回收的子进程的PID
(2)ret = waitpid(pid, &status, 0);        等待回收PID为pid的这个子进程，如果当前进程并没有一个ID号为pid的子进程，则返回值为负1；如果成功回收了pid这个子进程则返回值为回收的进程的PID ,0表示用默认的方式（阻塞式）来进行等待
(3)ret = waitpid(pid, &status, WNOHANG);这种表示父进程要【非阻塞式】的回收子进程。此时如果父进程执行waitpid时子进程已经先结束等待回收则waitpid直接回收成功，返回值是回收的子进程的PID；如果父进程waitpid时子进程尚未结束则父进程立刻返回（非阻塞），但是返回值为0（表示回收不成功）。
 
3.4.8.4、竟态初步引入
(1)竟态全称是：竞争状态，多进程环境下，多个进程同时抢占系统资源（内存、CPU运行时间、文件IO）
(2)竞争状态对OS来说是很危险的，此时OS如果没处理好就会造成结果不确定。
(3)写程序当然不希望程序运行的结果不确定，所以我们写程序时要尽量消灭竞争状态。操作系统给我们提供了一系列的消灭竟态的机制，我们需要做的是在合适的地方使用合适的方法来消灭竟态。
 
*******************************************************************************************************************************************************************************************
3.4.9.exec族函数及实战1
函数原型：
#include <unistd.h>
extern char **environ;
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 execvpe(const char *file, char *const argv[], char *const envp[]);
 
3.4.9.1、为什么需要exec函数
补充两点：
 
（1）exec函数说明
fork函数是用于创建一个子进程，该子进程几乎是父进程的副本，而有时我们希望子进程去执行另外的程序，exec函数族就提供了一个在进程中启动另一个程序执行的方法。它可以根据指定的文件名或目录名找到可执行文件，并用它来取代原调用进程的数据段、代码段和堆栈段，在执行完之后，原调用进程的内容除了进程号外，其他全部被新程序的内容替换了。另外，这里的可执行文件既可以是二进制文件，也可以是Linux下任何可执行脚本文件。
（2）在Linux中使用exec函数族主要有以下两种情况：
 
当进程认为自己不能再为系统和用户做出任何贡献时，就可以调用任何exec 函数族让自己重生。
如果一个进程想执行另一个程序，那么它就可以调用fork函数新建一个进程，然后调用任何一个exec函数使子进程重生。
 
 
(1)fork子进程是为了执行新程序(fork创建了子进程后，子进程和父进程同时被OS调度执行，因此子进程可以单独的执行一个程序，这个程序宏观上将会和父进程程序同时进行)
(2)可以直接在子进程的if中写入新程序的代码。这样可以，但是不够灵活，因为我们只能把子进程程序的源代码贴过来执行（必须知道源代码，而且源代码太长了也不好控制），譬如说我们希望子进程来执行ls -la 命令就不行了（没有源代码，只有编译好的可执行程序）
(3)使用exec族运行新的可执行程序（exec族函数可以直接把一个编译好的可执行程序直接加载运行）
(4)我们有了exec族函数后，我们典型的父子进程程序是这样的：子进程需要运行的程序被单独编写、单独编译连接成一个可执行程序（叫hello），（项目是一个多进程项目）主程序为父进程，fork创建了子进程后在子进程中调用exec函数族来执行hello，达到父子进程分别做不同程序同时（宏观上）运行的效果。
3.4.9.2、exec族的6个函数介绍
(1)execl和execv     这两个函数是最基本的exec，都可以用来执行一个程序，区别是传参的格式不同。execl是把参数列表（本质上是多个字符串，【必须以NULL结尾】）依次排列而成（l其实就是list的缩写），execv是把参数列表事先放入一个字符串数组中，再把这个字符串数组传给execv函数。
(2)execlp和execvp    这两个函数在上面2个基础上加了p，较上面2个来说，区别是：上面2个执行程序时必须指定可执行程序的【全路径】（如果exec没有找到path这个文件则直接报错），而加了p的传递的可以是file（也可以是path，只不过兼容了file。加了p的这两个函数会首先去找file，如果找到则执行，如果没找到则会去环境变量PATH所指定的目录下去找，如果找到则执行如果没找到则报错）
(3)execle和execvpe    这两个函数较基本exec来说加了e，函数的参数列表中也多了一个字符串数组envp形参，e就是environment环境变量的意思，和基本版本的exec的区别就是：执行可执行程序时会多传一个环境变量的字符串数组给待执行的程序。
3.4.9.3、exec实战1
(1)使用execl运行ls -l -a
(2)使用execv运行ls
(3)使用execl运行自己写的程序
 /*主要就是传参的注意  man 3 execl*/
 int execl(const char *path, const char *arg, ...);      //函数原型
代码示例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
//使用execl运行ls -l -a
#define PATH   "/bin/ls"
 
 
int main()
{
  int ret=-1;
  ret = fork();
  char *p[]={"PATH","-l","-a",NULL};      //字符串数组定义
  if(ret<0)
  {
      perror("fork:");
      _exit(-1);
  }
    if(ret == 0)  //子进程
    {
    //(1)execv(PATH,p);
    //(2)execl(PATH,"ls","-a","-l",NULL);
    // (3)执行自己的函数程序    execl("./hello","./hello",NULL);
}
    if(ret > 0)
    {
    printf("hello !\\n");
    sleep(1);   
    }
return 0;
}
hello.c代码示例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int  test(char * p, char *p2,int *numGet)
{
    int ret = 0;
    if(p ==NULL || p2 == NULL || numGet == NULL)
    {
        ret =-1;
        return ret;
    }
    char *pget=p;
    char *sub=p2;
    int *count=numGet;
    int i=0;
    while(pget=strstr(pget,sub))
    {
        i++;
        pget = pget+strlen(sub);
        if(*pget==\'\\0\')
        {
            break;
        }
   }
  *count = i;
  return ret;
}
 
int main()
{
    char *pw="afndaidsgsabc";
    char *subs ="a";
    int countn=0;
    int ret=0;
    ret=test(pw,subs,&countn);
    if(ret==0)
    {
        printf("次数为：%d\\n",countn);   
    }
  else
  {
      printf("出错了！\\n");
  }
  return 0;
  }
 
3.4.10.exec族函数及实战2
3.4.10.1、execlp和execvp
(1)加p和不加p的区别是：不加p时需要全部路径+文件名，如果找不到就报错了。加了p之后会多帮我们到PATH所指定的路径下去找一下。
 
3.4.10.2、execle和execvpe
(1)main函数的原型其实不止是int main(int argc, char **argv)，而可以是
int main(int argc, char **argv, char **env)    第三个参数是一个字符串数组，内容是环境变量。
(2)如果用户在执行这个程序时没有传递第三个参数，则程序会自动从父进程继承一份环境变量（默认的，最早来源于OS中的环境变量）；如果我们exec的时候使用execle或者execvpe去给传一个envp数组，则程序中的实际环境变量是我们传递的这一份（取代了默认的从父进程继承来的那一份）
注意：execle和execvpe的第三个环境变量参数是可以更改从系统环境变量继承过来的这一份的。
代码示例：
#include <unistd.h>
int main(int argc, char *argv[])
{
        char *envp[]={"PATH=/tmp", "USER=lei", "STATUS=testing", NULL};
        char *argv_execv[]={"echo", "excuted by execv", NULL};
        char *argv_execvp[]={"echo", "executed by execvp", NULL};
        char *argv_execve[]={"env", NULL};
        if(fork()==0) {
                if(execl("/bin/echo", "echo", "executed by execl", NULL)<0)
                        perror("Err on execl");
        }
        if(fork()==0) {
                if(execlp("echo", "echo", "executed by execlp", NULL)<0)
                        perror("Err on execlp");
        }
        if(fork()==0) {
                if(execle("/usr/bin/env", "env", NULL, envp)<0)
                        perror("Err on execle");
        }
        if(fork()==0) {
                if(execv("/bin/echo", argv_execv)<0)
                        perror("Err on execv");
        }
        if(fork()==0) {
                if(execvp("echo", argv_execvp)<0)
                        perror("Err on execvp");
        }
        if(fork()==0) {
                if(execve("/usr/bin/env", argv_execve, envp)<0)
                        perror("Err on execve");
        }
}
 
 
-----------------------------------------------------------------------------------------------------------------------------------------------------------