如何在 Linux 中使用参数执行 C 代码中的外部程序？

问题描述：

我想在 C 代码中执行另一个程序。例如，我想执行一个命令

./foo 1 2 3

foo是存在于同一文件夹中的程序，并且1 2 3是参数。
foo程序创建一个将在我的代码中使用的文件。

我该如何做？

解决方案 1：

简单的方法是使用system()：

#include <stdlib.h>
...
int status = system("./foo 1 2 3");

system()将等待 foo 完成执行，然后返回一个状态变量，您可以使用它来检查例如 exitcode（该命令的 exitcode 乘以 256，因此将 system() 的返回值除以该值即可获得实际的 exitcode：）int exitcode = status / 256。

的手册页wait()（在第 2 部分，man 2 wait在您的 Linux 系统上）列出了您可以用来检查状态的各种宏，其中最有趣的是WIFEXITED和WEXITSTATUS。

或者，如果您需要读取 foo 的标准输出，请使用popen(3)，它返回一个文件指针（FILE *）；与命令的标准输入/输出交互与读取或写入文件相同。

解决方案 2：

该system函数调用 shell 来运行命令。虽然这很方便，但众所周知它存在安全隐患。如果您可以完全指定要执行的程序或脚本的路径，并且可以承受失去所system提供的平台独立性，那么您可以使用下面函数execve中所示的包装器exec_prog来更安全地执行程序。

以下是在调用者中指定参数的方法：

const char    *my_argv[64] = {"/foo/bar/baz" , "-foo" , "-bar" , NULL};

然后exec_prog像这样调用该函数：

int rc = exec_prog(my_argv);

该函数如下exec_prog：

static int exec_prog(const char **argv)
{
    pid_t   my_pid;
    int     status, timeout /* unused ifdef WAIT_FOR_COMPLETION */;

    if (0 == (my_pid = fork())) {
            if (-1 == execve(argv[0], (char **)argv , NULL)) {
                    perror("child process execve failed [%m]");
                    return -1;
            }
    }

#ifdef WAIT_FOR_COMPLETION
    timeout = 1000;

    while (0 == waitpid(my_pid , &status , WNOHANG)) {
            if ( --timeout < 0 ) {
                    perror("timeout");
                    return -1;
            }
            sleep(1);
    }

    printf("%s WEXITSTATUS %d WIFEXITED %d [status %d]
",
            argv[0], WEXITSTATUS(status), WIFEXITED(status), status);

    if (1 != WIFEXITED(status) || 0 != WEXITSTATUS(status)) {
            perror("%s failed, halt system");
            return -1;
    }

#endif
    return 0;
}

记住包括：

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

有关需要通过文件描述符（如和）与执行程序进行通信的情况，请参阅相关的 SE 帖子。stdin`stdout`

解决方案 3：

您可以使用fork()并且system()这样您的程序就不必等到system()返回。

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

int main(int argc,char* argv[]){

    int status;

    // By calling fork(), a child process will be created as a exact duplicate of the calling process.
    // Search for fork() (maybe "man fork" on Linux) for more information.
    if(fork() == 0){ 
        // Child process will return 0 from fork()
        printf("I'm the child process.
");
        status = system("my_app");
        exit(0);
    }else{
        // Parent process will return a non-zero value from fork()
        printf("I'm the parent.
");
    }

    printf("This is my main program and it will continue running and doing anything i want to...
");

    return 0;
}

解决方案 4：

system()执行 shell，然后 shell 负责解析参数并执行所需程序。要直接执行程序，请使用 fork() 和 exec()（system() 使用这些函数执行 shell，shell 本身也使用这些函数执行命令）。

#include <unistd.h>

int main() {
     if (fork() == 0) {
          /*
           * fork() returns 0 to the child process
           * and the child's PID to the parent.
           */
          execl("/path/to/foo", "foo", "arg1", "arg2", "arg3", 0);
          /*
           * We wouldn't still be here if execl() was successful,
           * so a non-zero exit value is appropriate.
           */
          return 1;
     }

     return 0;
}

解决方案 5：

在 C 中

#include <stdlib.h>

system("./foo 1 2 3");

在 C++ 中

#include <cstdlib>

std::system("./foo 1 2 3");

然后像平常一样打开并读取文件。

解决方案 6：

这样怎么样：

char* cmd = "./foo 1 2 3";
system(cmd);

解决方案 7：

当您没有对参数进行硬编码时，这里有扩展到变量参数的方法（尽管在这个例子中它们在技术上仍然是硬编码的，但应该很容易弄清楚如何扩展......）：

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

int argcount = 3;
const char* args[] = {"1", "2", "3"};
const char* binary_name = "mybinaryname";
char myoutput_array[5000];

sprintf(myoutput_array, "%s", binary_name);
for(int i = 0; i < argcount; ++i)
{
    strcat(myoutput_array, " ");
    strcat(myoutput_array, args[i]);
}
system(myoutput_array);