如何用C++在Linux上實現進程間通信

在Linux上，有多種方法可以實現進程間通信（IPC）。以下是一些常用的IPC機制以及如何在C++中使用它們的示例：

1. 管道（Pipes）: 管道是一種半雙工的通信方式，通常用于父子進程之間的通信。

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

int main() {
    int pipefd[2];
    pid_t pid;
    char buffer[10];

    // 創建管道
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // 創建子進程
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid > 0) { // 父進程
        close(pipefd[0]); // 關閉讀端
        const char* message = "Hello from parent!";
        write(pipefd[1], message, strlen(message) + 1); // 寫入管道
        close(pipefd[1]); // 關閉寫端
        wait(NULL); // 等待子進程結束
    } else { // 子進程
        close(pipefd[1]); // 關閉寫端
        read(pipefd[0], buffer, sizeof(buffer)); // 從管道讀取
        std::cout << "Child received: " << buffer << std::endl;
        close(pipefd[0]); // 關閉讀端
    }

    return 0;
}

2. 命名管道（Named Pipes, FIFOs）: 命名管道是一種特殊類型的文件，允許不相關的進程進行通信。

#include <iostream>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    const char* fifo = "/tmp/myfifo";
    mkfifo(fifo, 0666);

    int fd = open(fifo, O_RDWR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    const char* message = "Hello from FIFO!";
    write(fd, message, strlen(message) + 1);

    char buffer[10];
    read(fd, buffer, sizeof(buffer));
    std::cout << "Received: " << buffer << std::endl;

    close(fd);
    unlink(fifo);

    return 0;
}

3. 消息隊列（Message Queues）: 消息隊列允許進程發送和接收消息。

#include <iostream>
#include <sys/ipc.h>
#include <sys/msg.h>

struct msg_buffer {
    long msg_type;
    char msg_text[100];
};

int main() {
    key_t key = ftok("msgfile", 65);
    int msgid = msgget(key, 0666 | IPC_CREAT);

    msg_buffer buffer;
    buffer.msg_type = 1;
    strcpy(buffer.msg_text, "Hello from message queue!");

    msgsnd(msgid, &buffer, sizeof(buffer.msg_text), 0);

    msgrcv(msgid, &buffer, sizeof(buffer.msg_text), 1, 0);
    std::cout << "Received: " << buffer.msg_text << std::endl;

    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

4. 共享內存（Shared Memory）: 共享內存是最快的IPC形式，因為它避免了內核空間的復制。

#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

int main() {
    key_t key = ftok("shmfile", 65);
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);

    char* str = (char*) shmat(shmid, (void*)0, 0);
    strcpy(str, "Hello from shared memory!");

    std::cout << "Shared memory: " << str << std::endl;

    shmdt(str);
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

5. 信號（Signals）: 信號是一種用于通知接收進程某個事件已經發生的機制。

#include <iostream>
#include <csignal>

void signal_handler(int signum) {
    std::cout << "Interrupt signal (" << signum << ") received.\n";
}

int main() {
    signal(SIGINT, signal_handler);

    // 暫停程序直到接收到信號
    while (true) {
        sleep(1);
    }

    return 0;
}

6. 套接字（Sockets）: 套接字是一種支持不同機器間通信的IPC機制。

// 這是一個簡單的TCP/IP套接字示例，包括服務器和客戶端

// 服務器端
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[1024] = {0};

    // 創建套接字文件描述符
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 綁定套接字到端口
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);

    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }

    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    if ((new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen)) < 0) {
        perror("accept");
        exit(EXIT_FAILURE);
    }

    read(new_socket, buffer, 1024);
    std::cout << "Message from client: " << buffer << std::endl;

    close(new_socket);
    close(server_fd);

    return 0;
}

// 客戶端
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cout << "
 Socket creation error 
";
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        std::cout << "
Invalid address/ Address not supported 
";
        return -1;
    }

    if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cout << "
Connection Failed 
";
        return -1;
    }

    send(sock, "Hello from client", strlen("Hello from client"), 0);
    std::cout << "Hello message sent\n";

    close(sock);

    return 0;
}

在使用這些IPC機制之前，請確保你已經安裝了必要的開發工具和庫。在編譯C++程序時，你可能需要鏈接特定的庫，例如-lrt用于實時庫，-lpthread用于線程支持等。