C 管道（）数据未传输到子进程

我正在尝试写入管道，并在exec执行到另一个文件时读取其内容，但由于某些原因，我无法使其工作

这是主.c文件

int main(int argc, char * argv[]) {
    int pipe_descs[2];
    int matrix[SIZE][SIZE];
    int fdr, fdw;   // file descriptors
    int i;
    pid_t status=0;
    if (pipe(pipe_descs) == -1) {
        fprintf(stderr, "cannot open");
        exit(1);
    }
    fdr = open(argv[1], O_RDONLY);   // open files
    fdw = open("gg.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);

    if (fdr < 0 || fdw < 0) { //validation for error
        perror("failed to open input or output files");
        exit(EXIT_FAILURE);
    }
    removeSpaces(matrix, fdr, fdw);
    status=fork();
    if (status < 0) {
        fputs("error in fork", stderr);
        exit(EXIT_FAILURE);
    }
    close(pipe_descs[0]);
    close(STDOUT_FILENO);
    dup(pipe_descs[1]);
    write(pipe_descs[1],matrix,sizeof(matrix));
    if(status == 0) {
        execl("rowsValidation", "rowsValidation", NULL);
        /*dup2(pipe_descs[IN],0);
        dup2(pipe_descs[OUT],4);
        close(STDOUT_FILENO);*/
    }
    …

intmain（intargc，char*argv[]）{
内部管道描述[2]；
整数矩阵[大小][大小]；
int fdr，fdw；//文件描述符
int i；
pid_t状态=0；
如果（管道（管道描述）=-1）{
fprintf（标准“无法打开”）；
出口（1）；
}
fdr=open（argv[1]，仅限ordu）；//打开文件
fdw=open（“gg.txt”，O|RDWR | O|CREAT | O|TRUNC，0644）；
如果（fdr<0 | | fdw<0）{//错误验证
perror（“无法打开输入或输出文件”）；
退出（退出失败）；
}
移除空间（矩阵、fdr、fdw）；
状态=fork（）；
如果（状态<0）{
fputs（“分叉错误”，标准）；
退出（退出失败）；
}
关闭（管道描述[0]）；
关闭（标准文件号）；
dup（管道描述[1]）；
写入（管道描述[1]，矩阵，尺寸（矩阵））；
如果（状态==0）{
execl（“rowsValidation”，“rowsValidation”，NULL）；
/*dup2（管道描述[IN]，0）；
dup2（管道描述[OUT]，4）；
关闭（标准文件号）*/
}
…

这是另一个文件，它试图从缓冲区读取数据，但什么也没发生

#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char * argv[]){
    int pipe_descs[2];
    int mat[9][9];


    int fdr, fdw;   // file descriptors
    char ans='9';
        int i, j;
    printf("%s","got here");
        close(pipe_descs[1]);
    close(STDIN_FILENO);
    dup(pipe_descs[0]);
    read(pipe_descs[0],mat,sizeof(mat));

    for (i = 0; i < 9; i++) { /* Iterate of each row */
        for (j = 0; j < 9; j++) { /* In each row, go over each col element  */
            printf("%d ", mat[i][j]); /* Print each row element */
        }
        printf("\n"); /* Finish a row, start a new line */
    }

    exit(0);
}

#包括
#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）{
内部管道描述[2]；
int mat[9][9]；
int fdr，fdw；//文件描述符
char ans='9'；
int i，j；
printf（“%s”，“到达这里”）；
关闭（管道描述[1]）；
关闭（标准文件号）；
dup（管道描述[0]）；
读取（管道描述[0]，材料，尺寸（材料））；
对于（i=0；i<9；i++）{/*每行迭代*/
对于（j=0；j<9；j++）{/*的每一行，检查每个列元素*/
printf（“%d”，mat[i][j]）；/*打印每行元素*/
}
printf（“\n”）；/*完成一行，开始新行*/
}
出口（0）；
}

在阅读了评论并在网上阅读了更多内容后，我把它改成了这样 我试着用一个字符来检查它，但我仍然无法使它工作。 父亲将char写入管道，儿子对新流程执行exec，然后它从管道读取，但仍然不起作用。 请帮我修一下

int main(int argc, char * argv[]) {
    int pipe_descs[2];
    int matrix[SIZE][SIZE];
    int fdr, fdw;   // file descriptors
    int i;
    char a='10';
    pid_t status=0;
    if (pipe(pipe_descs) == -1) {
        fprintf(stderr, "cannot open");
        exit(1);
    }
            fdr = open(argv[1], O_RDONLY);   // open files
            fdw = open("gg.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);
         if (fdr < 0 || fdw < 0) { //validation for error
             perror("failed to open input or output files");
             exit(EXIT_FAILURE);
         }
        removeSpaces(matrix, fdr, fdw);
         status=fork();
        if (status < 0) {
            fputs("error in fork", stderr);
            exit(EXIT_FAILURE);
        }
         if(status == 0) {

                dup2(pipe_descs[0], 0);     // read the matrix from pipe1 to 0
                close(pipe_descs[0]);
                dup2(pipe_descs[1], 4);
                printf("Execl1 start\n");
                                        // write to 4 instead of pipe1[1]
                execl("rowsValidation", "rowsValidation", NULL);


        }
         else{

                write(pipe_descs[1],&a,sizeof(char));
                close(pipe_descs[1]);


                    /*char buffer[10];
                            close(pipe_descs[1]);
                            close(STDIN_FILENO);
                            dup(pipe_descs[0]);
                            read(pipe_descs[0],buffer,sizeof(buffer));
                            printf("%s",buffer);
                            close(pipe_descs[0]);*/
         }
    close(fdr);   // close the files
    close(fdw);
    exit(EXIT_SUCCESS);
}



 int main(int argc, char * argv[]){
        int pipe_descs[2];
        int mat[9][9];


        int fdr, fdw;   // file descriptors
        char ans;
            int i, j;

        read(0,&ans,sizeof(char));
        printf("%c ", ans);
        for (i = 0; i < 9; i++) { /* Iterate of each row */
            for (j = 0; j < 9; j++) { /* In each row, go over each col element  */
                printf("%d ", mat[i][j]); /* Print each row element */
            }
            printf("\n"); /* Finish a row, start a new line */
        }
    /*  if (pipe(pipe_descs) == -1) {
            fprintf(stderr, "cannot open");
            exit(1);
        }*/
        //write(4,1,sizeof(char));
        exit(0);
    }

intmain（intargc，char*argv[]）{
内部管道描述[2]；
整数矩阵[大小][大小]；
int fdr，fdw；//文件描述符
int i；
字符a='10'；
pid_t状态=0；
如果（管道（管道描述）=-1）{
fprintf（标准“无法打开”）；
出口（1）；
}
fdr=open（argv[1]，仅限ordu）；//打开文件
fdw=open（“gg.txt”，O|RDWR | O|CREAT | O|TRUNC，0644）；
如果（fdr<0 | | fdw<0）{//错误验证
perror（“无法打开输入或输出文件”）；
退出（退出失败）；
}
移除空间（矩阵、fdr、fdw）；
状态=fork（）；
如果（状态<0）{
fputs（“分叉错误”，标准）；
退出（退出失败）；
}
如果（状态==0）{
dup2（管道描述[0]，0）；//从管道1到0读取矩阵
关闭（管道描述[0]）；
dup2（管道描述[1]，4）；
printf（“Execl1开始\n”）；
//写入到4而不是pipe1[1]
execl（“rowsValidation”，“rowsValidation”，NULL）；
}
否则{
写入（管道描述[1]，&a，大小（字符））；
关闭（管道描述[1]）；
/*字符缓冲区[10]；
关闭（管道描述[1]）；
关闭（标准文件号）；
dup（管道描述[0]）；
读取（管道描述[0]，缓冲区，大小（缓冲区））；
printf（“%s”，缓冲区）；
关闭（管道描述[0]）*/
}
关闭（fdr）；//关闭文件
关闭（fdw）；
退出（退出成功）；
}
int main（int argc，char*argv[]）{
内部管道描述[2]；
int mat[9][9]；
int fdr，fdw；//文件描述符
查尔安斯；
int i，j；
读取（0，&ans，sizeof（char））；
printf（“%c”，ans）；
对于（i=0；i<9；i++）{/*每行迭代*/
对于（j=0；j<9；j++）{/*的每一行，检查每个列元素*/
printf（“%d”，mat[i][j]）；/*打印每行元素*/
}
printf（“\n”）；/*完成一行，开始新行*/
}
/*如果（管道（管道描述）=-1）{
fprintf（标准“无法打开”）；
出口（1）；
}*/
//写入（4,1，sizeof（char））；
出口（0）；
}

我认为你对自己想要什么以及如何做略知一二，但你并不是100%了解。 如果要创建管道，请在其中写入信息并让另一个程序读取：首先创建管道，然后通过fork（）创建一个新进程，例如，（有些人建议不要使用fork:）并通过dup2（）和dup（）更改文件描述符创建管道、分叉和执行exec的过程可以通过popen（）调用轻松完成，我建议您仔细研究一下

以下是一个可能对您有所帮助的示例：

char*生成\u散列（char*密码，char*盐）
{
字符密码加盐[最大密码加盐]；
strcpy（密码加盐，密码）；
strcat（密码加盐，盐）；
int-fd[2]；
管道（fd）；
int stdout\u save=dup（stdout\u文件号）；
dup2（fd[WRITE]，标准输出文件号）；
文件*input=popen（“sha256sum”，“w”）；
fprintf（输入，密码加上盐，“%s”）；
文件*输出=fdopen（fd[READ]，“r”）；
pclose（输入）；
char*hash=（char*）malloc（sizeof（char）*（hash_LEN+1））；
memset（hash，'\0'，（hash_LEN+1）*sizeof（char））；
for（int i=0；i

我还建议您将错误切换为c