key_t ftok(const char *pathname, int proj_id);

struct shmid_ds {
    struct ipc_perm shm_perm;  // 权限
    size_t shm_segsz;          // 共享内存段大小
    time_t shm_atime;          // 最近一次附加时间
    time_t shm_dtime;          // 最近一次分离时间
    time_t shm_ctime;          // 创建时间
    pid_t shm_cpid;            // 创建该共享内存段的进程ID
    pid_t shm_lpid;            // 最后操作该共享内存段的进程ID
    shmatt_t shm_nattch;       // 附加到共享内存的进程数
};

#include"share.hpp"  // 引入头文件，假设这是包含共享内存相关函数声明的头文件。

using namespace std;  // 使用标准命名空间，简化代码书写。

int main()
{
    // 获取共享内存段的标识符
    int shmid = Getshmid();  
    // 使用shmat函数将共享内存映射到进程的地址空间
    char* shaddr = (char*)shmat(shmid, nullptr, 0);  
    // 定义一个shmid_ds结构体，用于存储共享内存段的状态信息
    struct shmid_ds shmds;
    
    // 调用shmctl函数获取共享内存段的状态
    int ret = shmctl(Getshmid(), IPC_STAT, &shmds);  
    // 输出共享内存的权限
    cout << "权限: " << shmds.shm_perm.mode << endl;
    // 输出共享内存的大小（字节数）
    cout << "共享内存大小: " << shmds.shm_segsz << endl;
    // 输出创建共享内存的进程ID
    cout << "创建共享内存的进程ID: " << shmds.shm_perm.mode << endl;
    // 输出共享内存的key值以及当前程序自定义的key值
    cout << "共享内存的key值: " << shmds.shm_perm.__key << "  自己创建的值：" << Get_key() << endl;
    
    // 使用shmdt解除共享内存的映射
    shmdt((void*)shaddr);

    return 0;  // 结束程序
}

class FIFO
{
public:
    // 构造函数：创建命名管道（FIFO）
    FIFO()
    {
        // 调用 mkfifo 创建命名管道，MYFIFO_PATH 是管道的路径，MODE 是文件权限
        int n = mkfifo(MYFIFO_PATH, MODE);
        
        // 检查 mkfifo 是否成功，若返回值为 -1，则表示创建失败
        if (n == -1)
        {
            // 如果创建失败，记录错误日志并退出程序
            log(fatal, "mkfifo failure: %s", strerror(errno));  // 输出错误日志，显示错误原因
            exit(4);  // 返回 4 表示创建管道失败
        }
        
        // 如果创建成功，记录成功日志
        log(info, "mkfifo success");  // 输出成功日志
    }

    // 析构函数：删除命名管道
    ~FIFO()
    {
        // 调用 unlink 删除命名管道
        int n = unlink(MYFIFO_PATH);
        
        // 检查 unlink 是否成功，若返回值为 -1，则表示删除失败
        if (n == -1)
        {
            // 如果删除失败，记录错误日志并退出程序
            log(error, "unlink failure: %s", strerror(errno));  // 输出错误日志，显示错误原因
            exit(4);  // 返回 4 表示删除管道失败
        }
        
        // 如果删除成功，记录成功日志
        log(info, "unlink success");  // 输出成功日志
    }
};

key_t GetKey()
{
    // 调用 ftok 函数，使用 pathname 和 proj_id 生成唯一的 IPC 键值
    key_t key = ftok(pathname.c_str(), proj_id);    
    // 检查 ftok 调用是否成功，key < 0 表示失败
    if (key < 0)
    {
        // 如果 ftok 失败，记录错误信息到日志，并返回 1
        log(fatal, "ftok failure:%s", strerror(errno)); // 错误日志输出，显示 errno 对应的错误信息
        return 1; // 返回 1 表示错误
    }
    // 如果成功，记录成功信息到日志
    log(info, "GetKey success"); // 成功日志输出
    // 返回生成的唯一 IPC 键值
    return key;

int GetShare_mm(int flag)
{
    // 使用获取的 IPC 键值（通过 GetKey 函数）和共享内存的大小（SIZE_MM）来调用 shmget 创建或获取共享内存
    int shmid = shmget(GetKey(), SIZE_MM, flag);
    
    // 检查 shmget 调用是否成功，如果返回值是 -1 表示创建或获取共享内存失败
    if (shmid == -1)
    {
        // 如果 shmget 失败，记录错误信息到日志，并返回 2 作为错误标识
        log(fatal, "shmget failure: %s", strerror(errno)); // 错误日志输出，显示 errno 对应的错误信息
        return 2; // 返回 2 表示共享内存获取失败
    }
    // 如果 shmget 成功，记录成功信息到日志
    log(info, "shmget success"); // 成功日志输出
    // 返回获取的共享内存标识符
    return shmid;
}

int main()
{
    // 创建一个命名管道 FIFO
    FIFO init;  // 假设 FIFO 是一个类，它的构造函数用于初始化命名管道。

    // 打开命名管道，打开模式是只读
    int fd = open("myfifo", O_RDONLY);
    if (fd == -1)
    {
        // 如果打开管道失败，记录错误并退出
        log(error, "open failure: %s", strerror(errno)); // 错误日志输出，显示 errno 对应的错误信息
        exit(5); // 返回 5 表示出现错误并退出
    }

    // 创建共享内存并获取共享内存标识符
    int shmid = CreateShmid();  // 假设 CreateShmid() 是创建共享内存的函数，它返回共享内存段的标识符。

    // 将共享内存映射到进程的地址空间
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    if ((void*)shmaddr == (void*)-1)
    {
        // 如果共享内存映射失败，记录错误并返回
        log(fatal, "shmat failure: %s", strerror(errno)); // 错误日志输出
        return 1; // 返回 1 表示出错
    }

    // 进入通信循环
    while (true)
    {
        char ch; 

#include "share.hpp"

int main()
{
    // 打开命名管道 "myfifo" 进行写操作 (O_WRONLY)
    int fd = open("myfifo", O_WRONLY);
    if (fd == -1)  // 如果打开管道失败，fd 会是 -1
    {
        // 记录管道打开失败的错误信息并退出程序
        log(error, "open failure: %s", strerror(errno)); 
        exit(5);  // 退出程序，返回错误码 5
    }
    // 获取共享内存的标识符
    int shmid = Getshmid();

    // 将共享内存映射到进程地址空间
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    if ((void*)shmaddr == (void*)-1)  // 检查映射是否成功
    {
        // 如果映射失败，记录错误信息并退出程序
        log(fatal, "shmat failure: %s", strerror(errno));
        return 1;  // 返回错误码 1
    }
    // 进入通信循环
    while (true)
    {
        // 提示用户输入
        std::cout << "Please Enter@ ";
        // 从标准输入读取数据并存储到共享内存
        fgets(shmaddr, SIZE_MM, stdin);  

        // 向管道写入字符 'x'，表示有新的消息
        int n = write(fd, "x", sizeof(char));  
    }
    // 解除共享内存映射
    shmdt((void*)shmaddr);
    return 0;  // 正常退出
}