C++ 进程间通信IPC的实现示例

#include <unistd.h>
#include <iostream>

int main() {
    int fd[2];
    pipe(fd); // 创建管道
    
    if (fork() == 0) { // 子进程
        close(fd[0]);   // 关闭读端
        write(fd[1], "Hello", 6);
        close(fd[1]);
    } else { // 父进程
        close(fd[1]);   // 关闭写端
        char buf[20];
        read(fd[0], buf, sizeof(buf));
        std::cout << "Received: " << buf << std::endl;
        close(fd[0]);
    }
    return 0;
}

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

// 进程1: 创建并写入FIFO
mkfifo("/tmp/myfifo", 0666);
int fd = open("/tmp/myfifo", O_WRONLY);
write(fd, "Hello FIFO", 10);
close(fd);

// 进程2: 读取FIFO
int fd = open("/tmp/myfifo", O_RDONLY);
char buf[20];
read(fd, buf, sizeof(buf));
close(fd);

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

struct message {
    long mtype;
    char mtext[100];
};

int main() {
    key_t key = ftok("progfile", 65);
    int msgid = msgget(key, 0666 | IPC_CREAT);
    
    message msg;
    msg.mtype = 1;
    sprintf(msg.mtext, "Hello Message Queue");
    
    // 发送消息
    msgsnd(msgid, &msg, sizeof(msg.mtext), 0);
    
    // 接收消息
    msgrcv(msgid, &msg, sizeof(msg.mtext), 1, 0);
    std::cout << "Received: " << msg.mtext << std::endl;
    
    // 删除消息队列
    msgctl(msgid, IPC_RMID, NULL);
    return 0;
}

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

int main() {
    key_t key = ftok("shmfile", 65);
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
    
    // 附加共享内存
    char *str = (char*)shmat(shmid, (void*)0, 0);
    
    std::cout << "Write Data: ";
    std::cin.getline(str, 1024);
    
    std::cout << "Data in memory: " << str << std::endl;
    
    // 分离共享内存
    shmdt(str);
    
    // 删除共享内存
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

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

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

int main() {
    key_t key = ftok("semfile", 65);
    int semid = semget(key, 1, 0666 | IPC_CREAT);
    
    semun su;
    su.val = 1; // 初始值
    semctl(semid, 0, SETVAL, su);
    
    sembuf sb = {0, -1, 0}; // P操作
    semop(semid, &sb, 1);
    
    // 临界区代码
    std::cout << "In critical section" << std::endl;
    
    sb.sem_op = 1; // V操作
    semop(semid, &sb, 1);
    
    return 0;
}

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

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    
    sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);
    
    bind(server_fd, (struct sockaddr*)&address, sizeof(address));
    listen(server_fd, 3);
    
    int new_socket = accept(server_fd, NULL, NULL);
    char buffer[1024] = {0};
    read(new_socket, buffer, 1024);
    std::cout << "Message: " << buffer << std::endl;
    
    close(new_socket);
    close(server_fd);
    return 0;
}

// 客户端
#include <sys/socket.h>
#include <arpa/inet.h>

int main() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    
    sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);
    inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);
    
    connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    send(sock, "Hello Socket", 12, 0);
    
    close(sock);
    return 0;
}

#include <signal.h>
#include <unistd.h>
#include <iostream>

void handler(int sig) {
    std::cout << "Received signal: " << sig << std::endl;
}

int main() {
    signal(SIGINT, handler); // 注册信号处理函数
    
    std::cout << "Waiting for signal..." << std::endl;
    pause(); // 等待信号
    
    return 0;
}

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

int main() {
    int fd = open("testfile.txt", O_RDWR | O_CREAT, 0666);
    
    // 获取排他锁
    if (flock(fd, LOCK_EX) == -1) {
        perror("flock");
        return 1;
    }
    
    // 临界区操作
    write(fd, "Hello File Lock", 15);
    
    // 释放锁
    flock(fd, LOCK_UN);
    close(fd);
    
    return 0;
}

// 服务器端
HANDLE hMailslot = CreateMailslot(
    "\\\\.\\mailslot\\sample_mailslot",
    0,
    MAILSLOT_WAIT_FOREVER,
    NULL);

// 客户端
HANDLE hFile = CreateFile(
    "\\\\.\\mailslot\\sample_mailslot",
    GENERIC_WRITE,
    FILE_SHARE_READ,
    NULL,
    OPEN_EXISTING,
    FILE_ATTRIBUTE_NORMAL,
    NULL);

// 创建者
HANDLE hFile = CreateFile("shared.dat", ...);
HANDLE hMap = CreateFileMapping(hFile, ...);
LPVOID pBuf = MapViewOfFile(hMap, ...);

// 访问者
HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, "SharedMemory");
LPVOID pBuf = MapViewOfFile(hMap, ...);

#include <dbus/dbus.h>

DBusConnection* conn = dbus_bus_get(DBUS_BUS_SESSION, NULL);
dbus_bus_request_name(conn, "com.example.Service", 0, NULL);

DBusMessage* msg = dbus_message_new_signal(
    "/com/example/Object",
    "com.example.Interface",
    "SignalName");
    
dbus_connection_send(conn, msg, NULL);
dbus_message_unref(msg);

// IDL定义
interface Hello {
    string sayHello();
};

// C++实现
class HelloImpl : public virtual POA_Hello {
public:
    char* sayHello() {
        return CORBA::string_dup("Hello CORBA!");
    }
};