c++ - 是否可以使用 boost windows_shared_memory 共享 vector ？

Question

刚刚开始使用 boost 库并熟悉它以找到解决我的问题的方法。

我试图解决的问题是无法在共享内存 (CreateFileMapping) 中的 Windows 上使用 STL 容器的限制。

我找不到使用 boost 中的 windows_shared_memory 共享 vector 的单个示例。但是有很多例子like this使用 managed_shared_memory。

请告知这是否可行并提供一个示例，当然许多其他开发人员对此感兴趣并会从中受益匪浅。

Answer 1

下面的片段是一个更大的项目的摘录，我实际上已经解决了这个问题。由于它只是片段，我可能会有一些不匹配。但我试图概述一般过程。

文档基本上都可以在boost文档中找到。但是它很简洁，并且只有两个关于托管共享内存的小示例。

通过这种方法，我什至能够在 64 位和 32 位进程之间共享 vector 和映射。它在字符串上失败，然后我将其交换为字符 vector 。

首先是命名空间:

namespace bipc = boost::interprocess;
namespace bc = boost::container;

如果 32 位 - 64 位兼容性不是问题，您可以使用简单的“托管”共享内存类型:

typedef bipc::managed_windows_shared_memory                    managed_shm_type;

您甚至可以使用基本(更独立于平台)类型。但这对共享内存的“持久性”有不同的影响。

typedef bipc::managed_shared_memory                            managed_shm_type;

但是如果你 需要 32/64 位兼容，需要使用修改后的内存类型。关键元素是 offset_ptr的定义它定义了内存对齐:

typedef bipc::basic_managed_windows_shared_memory
     <  char
     ,  bipc::rbtree_best_fit
        <
            bipc::mutex_family,
            bipc::offset_ptr<void, int64_t, uint64_t> // defines the "alignment"
        >
     ,  bipc::iset_index
     >                                                            managed_shm_type;

完成此操作后，您可以继续定义所需的 vector (和字符串)类型。基本规则是，对于每种类型，您还需要一个分配器。 (POD 类型除外)对于 map 类型，您需要同时使用键和值:

typedef managed_shm_type::segment_manager                    segment_manager_t;

typedef bc::scoped_allocator_adaptor<bipc::allocator<void, segment_manager_t> > void_allocator;
typedef void_allocator::rebind<char>::other                  char_allocator;
typedef bc::vector<char, char_allocator>                     char_vector;
typedef bc::basic_string
        <
            char,
            std::char_traits<char>,
            char_allocator
        >                                                    char_string;
typedef void_allocator::rebind<char_string>::other           string_allocator;

typedef bipc::offset_ptr<void, int64_t, uint64_t>            data_ptr;
typedef void_allocator::rebind<data_ptr>::other              data_ptr_allocator;
typedef bc::vector<data_ptr, data_ptr_allocator>             data_vector;

typedef void_allocator::rebind<int32_t>::other               int_allocator;
typedef bc::vector<int32_t, int_allocator>                   int_vector;

typedef bc::vector<char_string, string_allocator>            string_vector;

typedef std::pair<const SEGMENTID, uint32_t>                 segid_type;
typedef bipc::allocator<segid_type, segment_manager_t>       segid_type_allocator;
typedef bc::map
        <
            SEGMENTID,
            uint32_t,
            std::less<SEGMENTID>,
            segid_type_allocator
        >                                                    segid_map;

声明所有这些类型后，您可以开始在代码中使用它们:

// first get the shared memory segment
global_segment = std::make_unique<managed_shm_type>(bipc::create_only,
                                                    shmem_name.c_str(),
                                                    200000    );

// struct that is going to be allocated in shared memory
struct global_sharedMemory_data
{
    explicit global_sharedMemory_data(const char_allocator & void_alloc)
        :   declutter(50, false, void_alloc)
        ,   core_queue_name(void_alloc)
        ,   remote_queue_counter(0)
        ,   segment_id_map(void_alloc)
    {}

    int_vector              declutter;
    char_string             core_queue_name;
    uint32_t                remote_queue_counter;
    segid_map               segment_id_map;
};


global_sharedMemory_data *  globalShMem;

void_allocator alloc_inst (global_segment->get_segment_manager());
globalShMem = global_segment->construct<global_sharedMemory_data>
                            ("Name of Shared Object")(alloc_inst);

// write a string to shared memory
globalShMem->core_queue_name = "Alcatraz";