简单来说，使用system()：

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

system()将等待foo完成执行，然后返回一个状态变量，您可以使用它来检查例如exitcode（命令的exitcode乘以256，因此将system（）的返回值除以该值以获得实际的exitcode：int exitcode = status / 256）。
The manpage for wait()（在第2节中，Linux系统上的man 2 wait）列出了可以用来检查状态的各种宏，最有趣的是WIFEXITED和WEXITSTATUS。
或者，如果需要读取foo的标准输出，可以使用popen(3)，它返回一个文件指针（FILE *）;与命令的标准输入/输出交互则与从文件阅读或向文件写入相同。

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

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]\n",
            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>

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

您可以使用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.\n");
        status = system("my_app");
        exit(0);
    }else{
        // Parent process will return a non-zero value from fork()
        printf("I'm the parent.\n");
    }

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

    return 0;
}

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;
}

在C中

#include <stdlib.h>

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

在C++中

#include <cstdlib>

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

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

不如这样：

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

下面是当你没有硬编码args时扩展到变量args的方法（尽管在这个例子中它们仍然是硬编码的，但应该很容易弄清楚如何扩展...）：

#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);