通常我们使用了fork函数创建了一个子进程后，子进程会调用exec族函数执行另外一个程序。由于fork函数新建的子进程和父进程几乎一模一样（不过，后来引入了写时复制技术避免了这一点），因此需要使用exec函数使得子进程执行一个新的可执行程序。

我们之所以称exec为族函数是因为它有6种不同的形式，主要区别体现在参数上：

#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 execve(const char *filename, char *const argv[],
              char *const envp[]);

总体来说，exec族函数的参数分为三类：文件路径，命令行参数，环境变量。不论那个exec函数，最终都是将上述三类参数传递给可执行程序中的main函数。这里有一个新的概念，即环境变量，它定义了用户的工作环境，包括用户的主目录，终端的类型，当前用户，当前目录等信息。事实上，main函数的完整形式应该是：

int main(int argc, char *argv[], char **envp);

通常我们并没有显示指定环境变量，这是因为main函数每次都默认使用系统自定义的全局变量environ。另外，通过在终端输入env命令，也可查看当前的所有环境变量信息。可以看到，main函数中的argv[]和envp与exec函数的参数有对应关系。

初次接触exec族函数，易被这6种不同的调用形式搞得混乱。下面我们将依次从上述三个参数的角度来区分这些函数的细微区别。

1.可执行文件的路径

以p结尾的exec函数可以直接传递可执行程序的文件名，此时这类函数会自动在PATH环境变量所指定的目录下查找这个可执行文件；非p结尾的exec函数则必须显示指定可执行程序的完整路径；

2.命令行参数

以execl开始的exec函数必须以列表的形式传递所有的命令行参数，并且最终以NULL作为命令行参数的结束；而以execv开始的exec函数则以字符串指针数组的形式传递所有命令行参数；

3.环境变量

以e结尾的exec函数必须显示指定环境变量；而非p结尾的exec函数则使用默认的环境变量，也就是main函数中的环境变量；

虽然exec函数有6种不同的调用形式，但是每个函数实现的功能都是一样的，即完成新的可执行程序的装入。下面的这个程序很好的演示了不同exec函数的使用方法：

#include < unistd.h >
#include < stdio.h >

int main()
{
	char *envp[]={
		"PATH = /tmp",
	        "USER = edsionte",
		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");

	printf("goodbye!\n");
	return 0;
}
//结果：
edsionte@edsionte-desktop:~/edsionte$ ./sys_process
goodbye!
edsionte@edsionte-desktop:~/edsionte$ executed by execl
excuted by execv
executed by execvp
executed by execlp
PATH = /tmp
USER = edsionte
PATH = /tmp
USER = edsionte

这个程序分别使用不同的exec函数调用了echo或env命令，并根据所传递的不同参数显示不同结果。该程序可能每次运行后的显示顺序都有所不同，这是进程的并发性所导致的。

值得注意的是，我们通常所说的命令行参数是以argv数组的第一个元素开始的，而第0号元素是可执行程序的名称。以第一个if语句为例，execl函数为/bin目录下的echo程序传递了两个参数：”echo”和”executed by execl”。由于我们通过execl函数已经装入了/bin/echo程序，因此在调用execl函数时，第一个参数”echo”可以替换成任意字符串，但是这并不代表就不需要传递该参数。

我们也可以让exec函数去执行我们自己编写的可执行程序。下面这个例子很好的演示了父进程和子进程的关系：

/*
 *Author: edsionte
 *Email:  edsionte@gmail.com
 *Time:   2011/03/14
*/

#include < stdio.h >
#include < unistd.h >
#include < stdlib.h >

int main()
{
	int pid;
	int val = 0;

	pid = fork();
	if (pid == 0) {
		//child proces;
		printf("[Child %d] I will be a new process!\n", getpid());
		if (execl("./sleeping","first arg", "20", NULL) == -1) {
			printf("execl error!\n");
			exit(1);
		}
		printf("[Child %d] I never go here!\n", getpid());
	} else if (pid > 0) {
		printf("[Parent %d] I am running!\n", getpid());
		/*
		wait(&val);
		printf("[Parent %d] All my child were leaving..\n", getpid());
		*/
	} else {
		printf("fork error!\n");
		exit(1);
	}

	printf("[process %d] I am leaving..\n", getpid());
	return 0;
}
//sleeping.c程序
#include < stdio.h >
#include < unistd.h >

int main(int argc, char** argv)
{
	int sec;

	sec = atoi(argv[1]);
	while (sec != 0) {
		sleep(1);
		printf("[New Child %d] I am running and my parent is %d\n", getpid(), getppid());
		sec--;
	}

	return 0;
}

该程序使用了与进程有关的四个最基本的系统调用函数：fork(),exec(),wait()和exit()。对于该程序的具体分析如下：

1.父进程通过fork函数创建子进程，然后父进程打印自己的pid；

2.子进程首先打印自己的pid，再通过execve函数装入可执行程序sleeping，并通过execve函数向sleeping传递了一个参数“20”；

3.在sleeping程序中，将主函数中传递的参数作为计数器，并依次循环睡眠20s。并且循环打印当前的sleeping进程的pid以及其父进程pid；

4.由于父进程先于子进程退出，则sleeping进程成为孤儿进程，因此在sleeping打印的父进程pid为1；如果去掉程序中的注释部分，则父进程等待子进程退出后再退出，那么sleeping所打印的父进程pid即为父进程的pid；

5.如果子进程执行exec函数成功，则主程序中最后一条语句就不会被子进程执行。说明子进程在执行了exec函数后就与父进程完全脱离。另外，在子进程执行过程中也可以通过ps命令查看当前的进程存在情况；

参考：

1.http://www.ibm.com/developerworks/cn/linux/kernel/syscall/part3/

2.Linux C编程实战；童永清 著；人民邮电出版社；