在C语言中使用execl执行外部C程序时如何传参与通信？

1. execl完全可以向子进程传递有效参数 #

你给出的示例代码execl("./script", "script", argcv[i], NULL);本身就是传递参数的正确写法。execl的参数规则是：

• 第一个参数是要执行程序的绝对/相对路径
• 第二个参数对应子进程argv[0]，惯例用程序自身名称（可自定义）
• 从第三个参数开始，就是要传递给子进程的业务参数
• 最后必须以NULL结尾，标记参数列表结束

子进程可通过main(int argc, char *argv[])的argv数组获取这些参数，argc是参数总个数（包含argv[0]）。

2. 适合你场景的进程通信方案 #

你的核心需求是主程序处理完数据后传递给子进程，避免子进程读文件，根据数据量大小，有两种实用方案：

方案一：命令行参数（适合小数据量）

如果主程序处理的结果是短字符串、数值等小数据，直接通过execl参数传递是最简单的方式，无需额外通信机制。

主程序示例代码：

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

int main() {
    // 主程序先完成数据处理，得到结果
    char processed_result[] = "user_id_10086|score_95";
    
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程调用目标程序，传递处理后的结果
        execl("./child_proc", "child_proc", processed_result, NULL);
        // 仅当execl执行失败时才会走到这里
        perror("execl failed");
        return 1;
    } else if (pid > 0) {
        // 主程序等待子进程执行完毕，收回控制权
        wait(NULL);
        printf("子进程执行完成，已返回主程序\n");
    } else {
        perror("fork failed");
        return 1;
    }
    return 0;
}

子进程程序（child_proc.c）示例代码：

#include <stdio.h>

int main(int argc, char *argv[]) {
    // 检查是否收到参数
    if (argc < 2) {
        fprintf(stderr, "未收到主程序传递的参数\n");
        return 1;
    }
    
    // 获取主程序传递的结果
    char *received_data = argv[1];
    
    // 将结果写入文件（你的业务逻辑）
    FILE *fp = fopen("result.txt", "w");
    if (fp == NULL) {
        perror("fopen failed");
        return 1;
    }
    fprintf(fp, "%s\n", received_data);
    fclose(fp);
    
    return 0;
}

方案二：管道（适合大数据量）

如果主程序处理的结果数据量较大（超过系统ARG_MAX限制，不同系统该值通常在几十KB到几MB之间），命令行参数不再适用，此时可用匿名管道实现主进程到子进程的单向数据传递。

主程序示例代码：

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

int main() {
    int pipe_fd[2];
    // 创建匿名管道
    if (pipe(pipe_fd) == -1) {
        perror("pipe create failed");
        return 1;
    }

    pid_t pid = fork();
    if (pid == 0) {
        // 子进程：关闭管道写端，将标准输入重定向到管道读端
        close(pipe_fd[1]);
        dup2(pipe_fd[0], STDIN_FILENO);
        close(pipe_fd[0]);
        
        // 调用子进程程序，无需传递命令行参数
        execl("./child_proc_pipe", "child_proc_pipe", NULL);
        perror("execl failed");
        return 1;
    } else if (pid > 0) {
        // 主程序：关闭管道读端，向管道写入处理后的大数据
        close(pipe_fd[0]);
        char large_processed_data[102400]; // 100KB示例数据
        memset(large_processed_data, 'x', sizeof(large_processed_data)-1);
        large_processed_data[sizeof(large_processed_data)-1] = '\0';
        
        write(pipe_fd[1], large_processed_data, strlen(large_processed_data));
        close(pipe_fd[1]);
        
        // 等待子进程完成
        wait(NULL);
        printf("子进程执行完成，已返回主程序\n");
    } else {
        perror("fork failed");
        return 1;
    }
    return 0;
}

子进程程序（child_proc_pipe.c）示例代码：

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

int main() {
    // 从标准输入读取主程序通过管道传递的数据
    char *buffer = malloc(102401);
    if (buffer == NULL) {
        perror("malloc failed");
        return 1;
    }
    
    size_t read_len = fread(buffer, 1, 102400, stdin);
    buffer[read_len] = '\0';
    
    // 将数据写入文件
    FILE *fp = fopen("large_result.txt", "w");
    if (fp == NULL) {
        perror("fopen failed");
        free(buffer);
        return 1;
    }
    fwrite(buffer, 1, read_len, fp);
    fclose(fp);
    
    free(buffer);
    return 0;
}

补充说明 #

如果需要更高效的大数据共享（比如频繁传递数据），还可以考虑共享内存，但需要配合信号量等同步机制保证数据安全，实现复杂度较高，一般前两种方案足以覆盖你的需求。

内容的提问来源于stack exchange，提问作者lVitaD