更新

查看以下服务器端标题：

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
using namespace boost::interprocess;

typedef allocator<int, managed_shared_memory::segment_manager> ShmIntAllocator;
typedef vector<int, ShmIntAllocator> IntVector;

class A
{
public:
    A();
    A(string str, offset_ptr<IntVector> ints)
        : m_str(string(str)), m_ints(ints) {};
    ~A();

    string m_str;
    offset_ptr<IntVector> m_ints;
};

class B
{
public:
    B();
    B(offset_ptr<A> obj) : m_obj(obj);
    ~B();
    VOID DoSomethingUseful()
    {
        MessageBoxA(NULL, m_obj->m_str.c_str(), "SomethingUseful", MB_ICONINFORMATION);
    }

    offset_ptr<A> m_obj;
};

这是服务器端实现：

managed_shared_memory g_shm;
offset_ptr<A> g_objA = nullptr;
PVOID g_hMem = nullptr;

BOOL StartServer()
    // Create a shared memory pool
    try {
        g_shm = managed_shared_memory(create_only, "MySharedMem", OVR_MAPSIZE);
    } catch(interprocess_exception& e) {
        std::string msg(e.what());
        MessageBoxA(NULL, msg.c_str(), "Error", MB_ICONERROR);
        return FALSE;
    }

    // Construct a local class instance
    const ShmIntAllocator alloc_intVector (g_shm.get_segment_manager());
    offset_ptr<IntVector> ints = g_shm.construct<IntVector>(unique_instance)(alloc_intVector);
    ints->push_back(10);
    ints->push_back(20);
    ints->push_back(30);
    g_objA = new A("Testing", ints);
    B objB(g_objA);

    // Copy data into shared memory
    size_t len = sizeof(objB); // <-- Doesn't seem to make a difference if I set this to be something higher
    g_hMem = g_shm.allocate(len);
    std::memcpy(g_hMem, &objB, len);
    return TRUE;
}

VOID StopServer()
{
    // Free used resources

    if(g_objA) {
        delete g_objA;
        g_objA = nullptr;
    }

    try{
        g_shm.destroy<B>(unique_instance);
        g_shm.deallocate(g_hMem);
        g_hMem = nullptr;
        shared_memory_object::remove("MySharedMem");
    } catch(interprocess_exception& e) {
        std::string msg(e.what());
        MessageBoxA(NULL, msg.c_str(), "Error", MB_ICONERROR);
    }
}

客户端实现：

BOOL Connect()
{
    // Grab the shared memory pool and extract the class
    managed_shared_memory shm(open_only, "MySharedMem");
    std::pair<B*, std::size_t> ret = shm.find<B>(unique_instance); // <-- Always ends up being 0x00000000!
    B *objB = static_cast<B*>(ret.first);
    if(!objB) return FALSE;
    objB->DoSomethingUseful();
    return TRUE;
}

您会注意到managed_shared_memory::find()始终无法返回指向客户端的有效指针。但据我所知，代码完全有效。没有编译器警告或错误，所有内容似乎都运行顺利，直到这一点。

那为什么会失败呢？我怎样才能让它按预期工作？

Answer 1

指针的不同地址空间

当您分享价值观时，一切都很清楚。例如，当将float值（例如1234.5）放入共享内存时，在另一方面，您可以简单地阅读它。

但是当您共享复杂对象（包含指针）时，存在一个重要问题。两个进程的地址空间完全不同且不同。例如，您不能将std::vector对象放在共享内存中，因为它在process1中有一个指向其数据的指针，例如0x1ABF212这个数字对于process2来说毫无意义。

因此，您必须在共享内存中逐一记下std::vector项。阅读序列化技术以共享复杂数据。

此外，如果您坚持在进程之间共享复杂对象作为唯一对象，则可以使用特定内存分配器创建这些对象。

AFAIK Boost.Interprocess有分配器。它管理共享内存并在共享内存中创建指针，这对两个进程都有意义。

_{对不起，我的英文不好}

Answer 2

您正在尝试找到应该由唯一实例构造创建的B. Boost documentation说

find函数获取指向唯一可以使用此“唯一实例”机制创建的T类对象的指针。

但是在您的代码中，您正在分配原始内存并只复制B对象。因此，您的B未创建为唯一实例

所以我建议你改变你的代码如下：尝试使用

B &objB = *g_shm.construct<B>(unique_instance) (g_objA);

而不是

B objB(g_objA);

在进程之间共享类指针

更新

2 个答案: