共享内存bug

问题描述：

共享内存类

class SharedMemoryWithLock
{
private:
    HANDLE hMapFile;       // 共享内存文件映射句柄  
    void* pBuffer;         // 共享内存指针  
    HANDLE hMutex;         // 互斥锁句柄  
    std::wstring name;     // 共享内存和互斥锁的名称  

    // 禁止拷贝和赋值  
    SharedMemoryWithLock(const SharedMemoryWithLock&) = delete;
    SharedMemoryWithLock& operator=(const SharedMemoryWithLock&) = delete;

public:
    SharedMemoryWithLock(const std::wstring& name, size_t sizeInBytes)
        : name(name), hMapFile(nullptr), pBuffer(nullptr), hMutex(nullptr)
    {
        // 尝试打开已存在的共享内存  
        hMapFile = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, name.c_str());
        if (hMapFile == NULL) {
            // 如果打开失败（即共享内存不存在），则创建它  
            hMapFile = CreateFileMappingW(
                INVALID_HANDLE_VALUE,   // 使用分页文件  
                NULL,                   // 默认安全  
                PAGE_READWRITE,         // 保护模式  
                0,                      // 高32位文件大小  
                static_cast<DWORD>(sizeInBytes), // 低32位文件大小  
                name.c_str());          // 共享内存名称  

            if (hMapFile == NULL) {
                throw std::runtime_error("CreateFileMapping failed");
            }
        }

        // 映射到进程地址空间  
        pBuffer = MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 0);
        if (pBuffer == NULL) {
            throw std::runtime_error("MapViewOfFile failed");
        }

        // 创建互斥锁（始终创建，因为可能多个进程需要同步）  
        std::wstring mutexName = name + L"_Mutex";
        hMutex = CreateMutexW(NULL, FALSE, mutexName.c_str());
        if (hMutex == NULL) {
            throw std::runtime_error("CreateMutex failed");
        }
    }

    ~SharedMemoryWithLock()
    {
        // 取消映射共享内存视图  
        if (pBuffer != nullptr) {
            UnmapViewOfFile(pBuffer);
            pBuffer = nullptr;
        }

        // 释放互斥锁句柄  
        if (hMutex != nullptr) {
            CloseHandle(hMutex);
            hMutex = nullptr;
        }

        // 注意：我们没有关闭hMapFile，所以共享内存对象仍然存在  
        // 如果需要关闭共享内存对象，请在这里添加 CloseHandle(hMapFile);  
    }

    // 锁定共享内存  
    void Lock() {
        WaitForSingleObject(hMutex, INFINITE);
    }

    // 解锁共享内存  
    void Unlock() {
        ReleaseMutex(hMutex);
    }

    // 获取共享内存指针  
    void* GetBuffer() {
        return pBuffer;
    }

    // 其他你可能需要的方法...  
};

//自定义结构体类

struct Person

{

char name[200];

int age;

double weight;

}

struct Persons

{

int num;

Person all[12345678];

}

int main()

{

std::queue<Persons >* data_Persons _s =
new std::queue<Persons >();

// 创建一个sizeof(data_share_memory_group)字节的共享内存 
    SharedMemoryWithLock shm(L"MySharedMemory", sizeof(data_share_memory_group)); 
    while (true)
    {
        
        //将共享内存数据复制出来开始
        try
        {
            //锁定要共享内存  和 复制共享内存的空间
            std::unique_lock<std::mutex> lock(mtx_get_Share_mem);
            // 锁定共享内存  
            shm.Lock();
      // 解锁共享内存  
            shm.Unlock();

         }
        catch (const std::exception& e) {
            std::cerr << "Error: " << e.what() << std::endl;
        }

}

//在使用std::queue<Persons > 时，当struct Persons 中Person all[12345678];过大时，执行 shm.Lock()和shm.Unlock();会报错，将Persons中Person[1000],数组改成1000则不报错