// 父进程 signal(SIGINT, [](int sig){ kill(p1, SIGUSR1); kill(p2, SIGUSR2); });expected expression before ‘[’ token signal(SIGINT, [](int sig){

这段代码中的`[]`是lambda表达式的语法，可能是你的编译器不支持C++11的特性。你可以尝试把lambda表达式改写成普通函数的形式，例如：

void handle_signal(int sig) {
    kill(p1, SIGUSR1);
    kill(p2, SIGUSR2);
}

signal(SIGINT, handle_signal);

或者在编译选项中加上`-std=c++11`来启用C++11特性。

相关问题

软中断通信 使用系统调用fork( )创建2个子进程p1和p2，在父进程中使用系统调用signal( )捕捉来自键盘上的软中断信号SIGINT(即按Ctrl-C)，当捕捉到软中断信号SIGINT后，父进程使用系统调用kill( )分别向2个子进程发出软中断信号SIGUSR1和SIGUSR2，子进程捕捉到信号后分别输出信息“Child process p1 is killed by parent！”和“Child process p2 is killed by parent！”后终止。而父进程等待2个子进程终止后，输出信息“Parent process is killed！”后终止。

这个问题需要编写一个程序来实现，以下是一个可能的解决方案：

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

void handle_sigint(int sig) {
    // 在父进程中接收到 SIGINT 信号后向子进程发送信号
    if (sig == SIGINT) {
        printf("Received SIGINT, sending SIGUSR1 to p1 and SIGUSR2 to p2.\n");
        kill(p1, SIGUSR1);
        kill(p2, SIGUSR2);
    }
}

void handle_sigusr1(int sig) {
    // 在子进程 p1 中接收到 SIGUSR1 信号后输出信息并终止
    if (sig == SIGUSR1) {
        printf("Child process p1 is killed by parent!\n");
        exit(0);
    }
}

void handle_sigusr2(int sig) {
    // 在子进程 p2 中接收到 SIGUSR2 信号后输出信息并终止
    if (sig == SIGUSR2) {
        printf("Child process p2 is killed by parent!\n");
        exit(0);
    }
}

int main() {
    pid_t p1, p2;

    // 创建子进程 p1 和 p2
    p1 = fork();
    if (p1 < 0) {
        fprintf(stderr, "Failed to fork p1.\n");
        return 1;
    } else if (p1 == 0) {
        // 在子进程 p1 中注册 SIGUSR1 信号处理函数
        signal(SIGUSR1, handle_sigusr1);
        while (1) {
            // 子进程 p1 不断循环等待信号
        }
    } else {
        // 在父进程中继续创建子进程 p2
        p2 = fork();
        if (p2 < 0) {
            fprintf(stderr, "Failed to fork p2.\n");
            return 1;
        } else if (p2 == 0) {
            // 在子进程 p2 中注册 SIGUSR2 信号处理函数
            signal(SIGUSR2, handle_sigusr2);
            while (1) {
                // 子进程 p2 不断循环等待信号
            }
        } else {
            // 在父进程中注册 SIGINT 信号处理函数
            signal(SIGINT, handle_sigint);
            // 等待子进程 p1 和 p2 终止
            waitpid(p1, NULL, 0);
            waitpid(p2, NULL, 0);
            printf("Parent process is killed!\n");
            exit(0);
        }
    }

    return 0;
}

这个程序首先使用 `fork()` 创建了两个子进程 p1 和 p2，然后在父进程中注册了 SIGINT 信号处理函数 `handle_sigint()`。当父进程接收到 SIGINT 信号后，会调用 `handle_sigint()` 函数向子进程 p1 和 p2 分别发送 SIGUSR1 和 SIGUSR2 信号。在子进程 p1 和 p2 中分别注册了 SIGUSR1 和 SIGUSR2 信号处理函数，当它们接收到信号后会输出相应的信息并调用 `exit(0)` 终止进程。在父进程中使用 `waitpid()` 等待两个子进程终止，然后输出信息并终止进程。

详细分析以下代码#include <stdio.h> #include <signal.h> #include <unistd.h> #include <stdlib.h> #include <sys/wait.h> int pid1, pid2; int endflag = 0, pf1 = 0, pf2 = 0; void intdelete() { kill(pid1, 16); kill(pid2, 17); endflag = 1; } void int1() { printf("child process 1 is killed by parent!\n"); exit(0); } void int2() { printf("child process 2 is killed by parent!\n"); exit(0); } int main() { int exitpid; signal(SIGINT, SIG_IGN); signal(SIGQUIT, SIG_IGN); while ((pid1 = fork()) == -1); if (pid1 == 0) { printf("p1\n"); signal(SIGUSR1, int1); signal(16, SIG_IGN); pause(); exit(0); } else { while ((pid2 = fork()) == -1); if (pid2 == 0) { printf("p2\n"); signal(SIGUSR2, int2); signal(17, SIG_IGN); pause(); exit(0); } else { printf("parent\n"); signal(SIGINT, intdelete); /*接收DEL信号，并转intdelete()*/ waitpid(-1, &exitpid, 0); printf("parent process is killed!\n"); exit(0); } } }

这段代码是一个使用了信号处理的进程控制程序。程序中创建了两个子进程pid1和pid2，并且在父进程中对这两个子进程进行了控制。

程序中使用了信号处理函数来控制子进程的运行和退出。当父进程接收到SIGINT信号时，会调用intdelete函数，该函数会向子进程pid1和pid2发送信号，终止它们的运行。当子进程pid1接收到SIGUSR1信号时，会调用int1函数，该函数会输出一个提示信息，并退出子进程。当子进程pid2接收到SIGUSR2信号时，会调用int2函数，该函数同样会输出一个提示信息，并退出子进程。

在父进程中，使用了waitpid函数来等待子进程的结束。当子进程结束时，会向父进程发送一个信号，父进程收到信号后会输出一个提示信息，并退出程序。

总的来说，这段代码实现了对两个子进程的控制，当父进程接收到DEL信号时，可以同时终止两个子进程的运行。同时，子进程也可以通过接收到相应的信号来实现自己的退出。