Linux C++ 共享内存类封装实现

在 Linux 中，共享内存（Shared Memory） 是进程间通信（IPC）的重要方式之一，允许多个进程直接访问相同的物理内存区域。通过共享内存，进程可以高效地交换数据，而不需要通过消息队列、管道等方式进行数据传输。本文将介绍如何在 C++ 中封装共享内存操作，通过类的形式实现对共享内存的管理。

1. 共享内存的基本概念

共享内存允许多个进程通过映射到相同的物理内存区域进行通信。使用共享内存时，通常涉及以下系统调用：

shmget：创建或获取一个共享内存段。
shmat：将共享内存段映射到当前进程的地址空间。
shmdt：将共享内存段从当前进程的地址空间分离。
shmctl：控制共享内存段（删除、修改权限等）。

2. C++ 共享内存类设计

为了便于共享内存的使用和管理，可以将共享内存的操作封装成一个 C++ 类。这个类需要实现以下功能：

创建或打开共享内存段。
将共享内存映射到进程地址空间。
提供读写共享内存的接口。
管理共享内存的生命周期（包括自动分离和删除）。

3. 共享内存类的实现

以下是一个简单的共享内存类封装示例，它封装了共享内存的创建、读写和释放等功能。

3.1 共享内存类 `SharedMemory`

#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <cstring>
#include <stdexcept>

class SharedMemory {
public:
    // 构造函数：根据key创建或获取共享内存
    SharedMemory(key_t key, size_t size) : m_key(key), m_size(size) {
        // 创建或获取共享内存段
        m_shmid = shmget(m_key, m_size, 0666 | IPC_CREAT);
        if (m_shmid == -1) {
            throw std::runtime_error("Failed to create/get shared memory");
        }

        // 将共享内存段映射到当前进程地址空间
        m_data = shmat(m_shmid, nullptr, 0);
        if (m_data == (void*)-1) {
            throw std::runtime_error("Failed to attach shared memory");
        }
    }

    // 析构函数：自动分离和删除共享内存
    ~SharedMemory() {
        // 从当前进程分离共享内存
        if (shmdt(m_data) == -1) {
            std::cerr << "Failed to detach shared memory" << std::endl;
        }
    }

    // 写数据到共享内存
    void write(const void* data, size_t size) {
        if (size > m_size) {
            throw std::runtime_error("Data size exceeds shared memory size");
        }
        std::memcpy(m_data, data, size);
    }

    // 从共享内存读取数据
    void read(void* buffer, size_t size) {
        if (size > m_size) {
            throw std::runtime_error("Read size exceeds shared memory size");
        }
        std::memcpy(buffer, m_data, size);
    }

    // 删除共享内存
    void remove() {
        if (shmctl(m_shmid, IPC_RMID, nullptr) == -1) {
            throw std::runtime_error("Failed to remove shared memory");
        }
    }

private:
    key_t m_key;       // 共享内存的键
    size_t m_size;     // 共享内存的大小
    int m_shmid;       // 共享内存的ID
    void* m_data;      // 指向共享内存的指针
};

3.2 类方法解释

构造函数：在构造函数中，通过 shmget 创建或获取一个共享内存段，并通过 shmat 将其映射到进程地址空间。如果任一步骤失败，抛出异常。
析构函数：在对象销毁时，自动调用 shmdt 将共享内存从当前进程分离。
write 方法：通过 memcpy 将指定的数据写入共享内存。确保写入的数据大小不能超过共享内存的大小。
read 方法：从共享内存中读取数据到指定的缓冲区，读取的数据大小也不能超过共享内存的大小。
remove 方法：通过 shmctl 删除共享内存段。

4. 使用示例

以下是使用 SharedMemory 类的示例代码，展示了如何在两个进程之间通过共享内存进行数据交换。

4.1 进程 A：写入数据到共享内存

#include <iostream>
#include "SharedMemory.h"

int main() {
    try {
        // 创建或获取共享内存
        SharedMemory shm(1234, 1024);
  
        // 写入数据到共享内存
        const char* message = "Hello from Process A";
        shm.write(message, strlen(message) + 1);  // 包括结尾的空字符
        std::cout << "Process A wrote to shared memory: " << message << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

4.2 进程 B：从共享内存读取数据

#include <iostream>
#include "SharedMemory.h"

int main() {
    try {
        // 连接到共享内存
        SharedMemory shm(1234, 1024);
  
        // 从共享内存读取数据
        char buffer[1024];
        shm.read(buffer, sizeof(buffer));
        std::cout << "Process B read from shared memory: " << buffer << std::endl;

        // 删除共享内存段
        shm.remove();
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

5. 编译和运行

编译共享内存类和两个进程的代码：

g++ -o processA processA.cpp
g++ -o processB processB.cpp

首先运行进程 A，它会将数据写入共享内存：

./processA

然后运行进程 B，它会读取共享内存中的数据并输出：

./processB

6. 共享内存类的优化和扩展

线程安全：当前的 SharedMemory 类并没有针对多线程环境进行处理。为了确保线程安全，可以在读写操作中添加互斥锁（mutex）进行同步。
错误处理：共享内存操作中可能会出现多种错误，例如内存不足或权限问题。可以通过日志记录来追踪这些错误。
内存大小管理：在实际应用中，可以进一步扩展类，支持动态调整共享内存的大小。