Fork() вместо getpid

int answers;
void signalReceiverInt(int sig)
{
    //printf("получен SIGINT\n");
    signal(sig ,&signalReceiverInt);
    answers++;
}
 
void signalReceiverAlrm(int sig)
{
    signal(sig ,&signalReceiverAlrm);
        kill(getppid(), SIGINT);
        //printf("Сингал SIGALR для PID=%i, родитель PPID=%i\n", getpid(), getppid());
}
 
int main(int argc, char *argv[]){
    
    answers=0;
    int count=atoi(argv[1]);
    int prc[count];
    signal(SIGINT   ,&signalReceiverInt);
    signal(SIGALRM   ,&signalReceiverAlrm);
    
    int mainPid=getpid();
    printf("mainPid: %d\n",mainPid);
    int i;
    for (i=0; i<count; i++)
        if(mainPid==getpid())
            prc[i]=fork();
    
    if(mainPid==getpid())
    {
 
        sleep(1);
        for (i = 0; i < count; i++){
            kill(prc[i], SIGALRM);
            sleep(10);
        }
        
        if(count!=answers){
            exit(0); 
        }else{
 
            //Убиваем процессы,если откликнулись не все
            for (i = 0; i < count; i++) 
                kill(prc[i], SIGKILL);
            int maxCode=0;
            int ecode=0;
 
            for (i = 0; i < count; i++)
            {
                waitpid(prc[i], &ecode, NULL);
                if(ecode > maxCode)
                    maxCode=ecode;
            }
            exit(maxCode);
        }
    } else {
    //printf("NUM: %d\n",x);
    //printf("NUM: %d\n",y);
    while(1)
    {
        sleep(1);
    }
}
 
       exit(0);

int pid; // переменная которая содержит PID (идентификатор процесса, просто его опознавательный номер)
pid = fork(); // создаем дочерний процесс.
// тут очень важный момент, в РОДИТЕЛИ, переменная pid будет содержать ИДЕНТИФИКАТОР ДОЧЕРНЕГО ПРОЦЕССА, который не равен нулю
// у ПОТОМКА, переменная pid будет равна НУЛЮ
// То есть если написать так (как в вашей программе)
if (p1 = fork())
 {
   // КОД КОТОРЫЙ БУДЕТ ВЫПОЛНЯТЬ РОДИТЕЛЬ
 }
else
{
 // КОД, КОТОРЫЙ ВЫПОЛНИТ ДОЧЕРНИЙ ПРОЦЕСС, ПОТОМУ ЧТО p1 = 0 у потомка!
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
 
int fact(int a);
 
int main(int argv, char *args[])
{
    int n = atoi(args[1]);
    int k = atoi(args[2]);
    int p1,p2,p3;
    int *st;
       
        /*
         * Возвращаемые значения fork() очень интересны.
         * Одно из них - 0, другое – ненулевое значение (PID - ID процесса).
         * Процесс, который получает 0, называется ПОРОЖДЕННЫМ процессом,
         * а ненулевое значение (PID - ID процесса) достается исходному процессу, который является родительским процессом.
         * Возвращаемые значения используют, для того чтобы определить, где какой процесс.
         */
    if(p1=fork())
    {
                /* Этот блок кода (три нижних if'а) предназначен для родительского процесса
                 * Потому что fork() возвращает идентификатор процесса (PID) родителю,
                 * а потомку возвращается 0 !!!
                 * По этой причине, код в третьем else, предназначен для первого потомка !!!
                 * Назовем этого родителя Алиса :)
                 */
 
                /* На данном этапе, Алиса породила дочь Алиса_1  
                 * УЖЕ породила
                 */
 
                /*
                 * Теперь идет порождение второго потомка Алисы, то есть Алисы_2
                 */
        if(p2=fork())
        {
                        /*
                         * На данном этапе Алиса породила дочь Алиса_2
                         */
 
                        /*
                     * Теперь идет порождение третьего потомка Алисы, то есть Алисы_3
                     */
            if(p3=fork())
            {
                                /* Код ниже предназначен для Алисы!!! ДЛЯ ИЗНАЧАЛЬНОГО РОДИТЕЛЯ, КАК И ВСЕ В if'ах!!!*/
 
                                /* на данном этапе Алиса породила дочь Алиса_3 */
 
                                /*
                                 * Дочерние процессы созданы.
                                 * Чтобы родители ожидали завершения дочернего процесса
                                 * необходимо сделать это явно, то есть вызвав функции waitpid()
                                 * Даже по названию видно предназначение
                                 * wait - ждать, pid = process ID, то есть идентификатор процесса
                                 * в данном случае, p1,p2,p3 - это ID Алисы_1,Алисы_2,Алисы_3!!!
                                 */
 
                                /* Алиса (родитель) ждет пока потомки Алиса_1,Алиса_2,Алиса_3
                                 * выполнят свою работу, тоесть код в else'ах!
                                 */
                waitpid(p1,st,0);
                waitpid(p2,st,0);
                                waitpid(p3,st,0);
                /*
                                 * То есть теперь программа замерла и ждёт
                                 * Когда выполнится код в else !!!
                                 * Во всех трех else!!!
                                 * Теперь стоит прочесть, что происходит в else'ах
                                 */
 
                                /*
                                 * После того как код в else'ах выполнился
                                 * мы открываем файлы на чтение
                                 */
                FILE * nkff = fopen("nkf.txt","r");
                FILE * kff = fopen("kf.txt","r");
                FILE * nff = fopen("nf.txt","r");
                   
                int nkf, kf, nf;
                /* считываем из файлов значения факторилов и записываем их в переменные nkf,kf,kff */                        
                fscanf(nkff, "%d",&nkf);
                fscanf(nff, "%d", &nf);
                fscanf(kff, "%d", &kf);
                /* выводим в консоль значения этих переменных */    
                printf("%d nkf\n", nkf);
                printf("%d nf\n", nf);
                printf("%d kf\n", kf);
                /* удаляем созданные файлы*/    
                unlink("nkf.txt");
                unlink("nf.txt");
                unlink("kf.txt");
                /*производим какие-то вычисления*/    
                double ret = nf/(kf*nkf);
                                /* выводим конечный результат */
                printf("%f\n", ret);
                   
                return 0;
                               
            }
                 /*
                  * Код внутри трех нижних else'ов
                  * Предназначен для потомков
                  */
            else
            {
                                /*
                                 * Этот блок кода предназначен для Алисы_3!!!
                                 */
                                /* n и k - это два передаваемых нашей программе параметра */
                                /* в функцию fact() передаем их разность */
                                /* теперь стоит прочесть комменты к этой функции, чтоб понять как она работает ^:) */
                int nkf = fact(n-k);
                                /* в переменной nkf у нас лежит факториал числа*/
 
                                /* Открываем файл */
                FILE * nkff = fopen("nkf.txt","w");
                                /* Записываем значение факториала числа в файл */
                fprintf(nkff, "%d", nkf);
                                /* Закрываем файл, чтобы освободить дескриптор*/
                fclose(nkff);
            }
        }
        else
        {
                                /*
                                 * Этот блок кода предназначен для второго потомка, Алисы_2!!!
                                 */
                                /*Все аналогично первому else */
            int kf = fact(k);
            FILE * kff = fopen("kf.txt","w");
            fprintf(kff, "%d", kf);
            fclose(kff);
        }
    }
    else
    {
                /*
                 * Этот блок кода предназначен для первого потомка Алиса_1!!!
                 * Почему?
                 * Потому что p1=fork() - возвращает 0 потомку и PID родителю!
                 */
                        /*Все аналогично первому else */
        int nf = fact(n);
        FILE * nff = fopen("nf.txt","w");
        fprintf(nff, "%d", nf);
        fclose(nff);
    }
   
    return 0;  
}
 
int fact(int a)
{
    int sum = 1;
        /* Если первый передаваемый параметр больше второго, то их разность будет отрицательна
         * Поэтому мы умножаем на -1, чтобы было положительное значение
         * То есть по сути не важно, какой параметр передавать первым, а какой вторым
         */
    if(a<0)
        a*=-1;
    /* вычисляем факторил разности параметров, то есть тупо перемножаем все предыдущие числа до него, с шагом один*/
    for(int i=1;i<=a;i++)
        sum*=i;
    /* ну и возвращаем результат. Почему переменная называется sum, хотя это не сумма - не знаю :) */    
    return sum;
}