C progam未填充应按条件填充的写入文件

我正在编写一个C程序，通过shell接收一个文件（logfile）和一些其他参数。该程序的目标是获取该文件，将其划分为多个文件（与nmappers的值一样多），并将每个新文件分配给一个进程，以便进程可以读取这些文件的某些内容，并生成一些新文件在其上写入。输入文件的数量（称为分割文件）和输出文件的数量（称为buf文件）都是nmappers变量的值

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


bool validarEntrada(int argc, char *argv[]);
bool validarConsulta(char *consulta, int *col, int *val, char **signo);

int main(int argc, char *argv[])
{
  int opc, col, val, lineas, nmappers, nreducers, intermedios, lineasPorArchivo, lineasHuerfanas;
  int cuentaArchivo=1, cuentaRegistro=0, ncol=0;
  bool salir = false, tieneHuerfana = false, encontroCadena = false;
  char *consulta = (char*) malloc(10);
  char *signo = (char*) malloc(2); 
  FILE *ptrLectura, *ptrEscritura;
  char registro[150], nombreArchivo[10], cadena[25], caracter;

  if(validarEntrada(argc,argv))
  { 
    lineas = atoi(argv[2]);
    nmappers = atoi(argv[3]);
    nreducers = atoi(argv[4]);
    intermedios = atoi(argv[5]);

    printf("%d\n", nreducers);

    do
    { 
      printf("\n1. Realizar consulta");
      printf("\n2. Salir del sistema");
      printf("\nopc: ");
      scanf("%d",&opc);

      switch(opc)
      {
        case 1: 
            printf("Ingrese la consulta que quiere hacer: ");
            scanf("%s",consulta);

            if(validarConsulta(consulta, &col, &val, &signo))
            {
              printf("\n[EN PROCESO]-Buscando registros de la columna %d que sean %s %d\n", val, signo, col);
              printf("\n[EN PROCESO]-Generando archivos buf necesarios");

              ptrLectura = fopen("logfile","r");
              if (!ptrLectura)
                return -1;

              lineasPorArchivo = lineas/nmappers;
              lineasHuerfanas = lineas%nmappers;

              sprintf(nombreArchivo, "split%d", cuentaArchivo);
              ptrEscritura = fopen(nombreArchivo, "w");

              while (fgets(registro, sizeof registro, ptrLectura) != NULL) 
              {
                if(cuentaRegistro == lineasPorArchivo) 
                {
                  fclose(ptrEscritura);
                  cuentaRegistro = 0;
                  cuentaArchivo++;
                  sprintf(nombreArchivo, "split%d", cuentaArchivo);
                  ptrEscritura = fopen(nombreArchivo, "w");
                  tieneHuerfana = false;
                  if (!ptrEscritura)
                    return -1;
                }
                fprintf(ptrEscritura,"%s", registro);
                cuentaRegistro++;
                if(lineasHuerfanas > 0 && !tieneHuerfana)
                {
                  if(fgets(registro, sizeof registro, ptrLectura) != NULL)
                  {
                    fprintf(ptrEscritura,"%s", registro);
                    lineasHuerfanas--;
                    tieneHuerfana = true;
                  }
                }
              }
              fclose(ptrLectura);
              fclose(ptrEscritura);

              //SE CREAN LOS nmappers PROCESOS PARA QUE CREEN LOS BUF

              for(int i = 1; i <= nmappers; i++)
              {
                if(fork() == 0)
                {
                  printf("HOLA%d", i);  ///////////////////HERE///////////////////////////////////////////////
                  sprintf(nombreArchivo, "split%d", i);
                  ptrLectura = fopen(nombreArchivo, "r");
                  sprintf(nombreArchivo, "buf%d", i);
                  ptrEscritura = fopen(nombreArchivo, "w");

                  while((caracter = fgetc(ptrLectura)) != EOF)
                  {
                    if(caracter != ' ' && caracter != '\n' && !encontroCadena)
                    {
                      strncat(cadena, &caracter, 1);//Pa que sirva toca con &
                      ncol++;
                      encontroCadena = true;
                    }
                    else if(caracter != ' ' && caracter != '\n' && encontroCadena)
                    {
                      strncat(cadena, &caracter, 1);//Pa que sirva toca con &
                    }
                    else if(caracter == ' ')
                    {
                      encontroCadena = false;
                    }
                    if(caracter == '\n')
                    {
                      fprintf(ptrEscritura, "%s\n", cadena);
                      ncol = 0;
                    }
                  }
                  exit(0);
                }
              }

            }
            else
            {
              printf("\n[ERROR]-Solo se aceptan los signos: [<|<=|>|>=|=]");
              printf("\n       -El formato debe ser: columna,signo,valor\n");
            }
          break;
        case 2:
            salir = true;
          break;
        default:
            printf("\nLa opcion %d NO es valida, escoja una opcion valida!\n", opc);
          break;
      }

      wait(NULL);

    }while(!salir);
  }
  else
  {
    return -1;
  }
  return 0;
}

bool validarEntrada(int argc, char *argv[])
{
  int lineas,nmappers,nreducers,intermedios;
  
  if(argc != 6)
  {
    printf("\n[ERROR]-El uso correcto es: $ analogp logfile lineas nmappers nreducers intermedios\n");
    return false;
  }
    
  lineas = atoi(argv[2]);
  nmappers = atoi(argv[3]);
  nreducers = atoi(argv[4]);
  intermedios = atoi(argv[5]);

  if(lineas <= 0 || nmappers <= 0 || nreducers <= 0)
  {
    printf("\n[ERROR]-Se debe cumplir que: lineas, nmappers, nreducers > 0\n");
    return false;
  }
  if(nreducers > nmappers)
  {
    printf("\n[ERROR]-Se debe cumplir que: nreducers <= nmappers\n");
    return false;
  }
  if(intermedios != 0 && intermedios != 1)
  {
    printf("\n[ERROR]-Se debe cumplir que: intermedios ∈ {0,1}\n");
    return false;
  }
    
  return true;
}

bool validarConsulta(char *consulta, int *col, int *val, char **signo)
{
  char *columna, *simbolo, *valor;

  columna = strtok(consulta, ",");
  *signo = strtok(NULL,",");
  valor = strtok(NULL,",");
  *col = atoi(columna);
  *val = atoi(valor);

  return (strcmp(*signo,"<") == 0 || strcmp(*signo,"<=") == 0  || strcmp(*signo,">") == 0 || strcmp(*signo,">=") == 0 || strcmp(*signo,"=") == 0);
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
bool validarEntrada（int-argc，char*argv[]）；
bool VALIDARCOUNTA（字符*符号，整数*字符，整数*字符，字符**符号）；
int main（int argc，char*argv[]）
{
int opc、col、val、lineas、nmappers、Nreducer、intermedios、lineasPorArchivo、Lineashuerfans；
int cuentaArchivo=1，cuentaRegistro=0，ncol=0；
bool-salir=false，tieneHuerfana=false，encontroCadena=false；
char*consulta=（char*）malloc（10）；
char*signo=（char*）malloc（2）；
文件*ptrLectura，*ptrEscritura；
char registro[150]，nombreArchivo[10]，cadena[25]，caracter；
if（validarEntrada（argc，argv））
{ 
lineas=atoi（argv[2]）；
nmappers=atoi（argv[3]）；
nReducer=atoi（argv[4]）；
中间层=原子（argv[5]）；
printf（“%d\n”，nReducer）；
做
{ 
printf（“\n1.变现顾问”）；
printf（“\n2.Salir del sistema”）；
printf（“\nopc:”）；
scanf（“%d”和&opc）；
交换机（opc）
{
案例1：
printf（“安格尔领事馆”）；
scanf（“%s”，领事）；
if（validarConsulta（consulta、col、val、signo））
{
printf（“\n[EN PROCESO]-在列%d的位置注册，并在列%s%d\n”，val，signo，col）；
printf（“\n[EN PROCESO]-通用档案库（Generando archivos buf necesarios”）；
ptrLectura=fopen（“日志文件”，“r”）；
如果（！ptrlecutra）
返回-1；
lineasPorArchivo=lineas/nmappers；
lineasHuerfanas=lineas%n映射；
sprintf（nombreArchivo，“分割%d”，cuentaArchivo）；
ptrEscritura=fopen（nombreArchivo，“w”）；
while（fgets（registro，sizeof registro，ptrLectura）！=NULL）
{
如果（cuentaRegistro==lineasPorArchivo）
{
fclose（ptrEscritura）；
Cuentaro=0；
Cuentaarcivo++；
sprintf（nombreArchivo，“分割%d”，cuentaArchivo）；
ptrEscritura=fopen（nombreArchivo，“w”）；
tieneHuerfana=假；
如果（！ptrEscritura）
返回-1；
}
fprintf（ptrEscritura，“%s”，registro）；
Cuentaro++；
if（lineashuerfana>0&！tieneHuerfana）
{
if（fgets（registro，sizeof registro，ptrLectura）！=NULL）
{
fprintf（ptrEscritura，“%s”，registro）；
莱纳舒尔法纳——；
tieneHuerfana=真；
}
}
}
fclose（ptrLectura）；
fclose（ptrEscritura）；
//这是一个很好的解决方案
对于（int i=1；i）这是一大堆需要检查的代码。请进一步说明。您是否尝试过在调试器中逐行运行代码，同时监视所有变量的值，以确定程序在哪一点停止按预期运行？如果您没有尝试此操作，则可能需要阅读此内容：您可能还需要阅读此内容：.Hint:在执行
printf
时，请以
\n
结束格式字符串。这将确保刷新输出缓冲区，并且在崩溃时您可能会看到输出。因此，请执行
printf（“HOLA%d\n，i）；
而不是
printf（“HOLA%d，i）；
   for(int i = 1; i <= nmappers; i++)
              {
                if(fork() == 0)
                {
                  printf("HOLA%d", i);  //////////////////////////////////////////////////////////////////
                  sprintf(nombreArchivo, "split%d", i);
                  ptrLectura = fopen(nombreArchivo, "r");
                  sprintf(nombreArchivo, "buf%d", i);
                  ptrEscritura = fopen(nombreArchivo, "w");

                  while((caracter = fgetc(ptrLectura)) != EOF)
                  {
                    if(caracter != ' ' && caracter != '\n' && !encontroCadena)
                    {
                      strncat(cadena, &caracter, 1);//Pa que sirva toca con &
                      ncol++;
                      encontroCadena = true;
                    }
                    else if(caracter != ' ' && caracter != '\n' && encontroCadena)
                    {
                      strncat(cadena, &caracter, 1);//Pa que sirva toca con &
                    }
                    else if(caracter == ' ')
                    {
                      encontroCadena = false;
                    }
                    if(caracter == '\n')
                    {
                      fprintf(ptrEscritura, "%s\n", cadena);
                      ncol = 0;
                    }
                  }
                  exit(0);
                }
              }

            }