C++类构造中的指针

Question

我这几天一直在努力解决这个问题。

在这个程序中，有一个从字符串键到结构体值的unordered_map。这个想法是可行的，但是当我将 unordered_map 放入一个类中，然后更轻松地访问它时，我收到一个错误：

Eliminare.exe!std::_Hash<std::_Umap_traits<std::string,Data,std::_Uhash_compare<std::string,std::hash<std::string>,std::equal_to<std::string>>,boost::interprocess::allocator<std::pair<std::string,Data>,boost::interprocess::segment_manager<char,boost::interprocess::rbtree_best_fit<boost::interprocess::mutex_family,boost::interprocess::offset_ptr<void,__int64,unsigned __int64,0>,0>,boost::interprocess::iset_index>>,0>>::_Find_last<std::string>(const std::string & _Keyval, const unsigned __int64 _Hashval) Row 1510    C++
    Eliminare.exe!std::unordered_map<std::string,Data,std::hash<std::string>,std::equal_to<std::string>,boost::interprocess::allocator<std::pair<std::string,Data>,boost::interprocess::segment_manager<char,boost::interprocess::rbtree_best_fit<boost::interprocess::mutex_family,boost::interprocess::offset_ptr<void,__int64,unsigned __int64,0>,0>,boost::interprocess::iset_index>>>::at(const std::string & _Keyval) Riga 387    C++
Eliminare.exe!MapCreator::getValue(std::string Key) Row 37  C++
Eliminare.exe!main() Row 7  C++

这是主要内容：

#include "MapCreator.h"

int main() {
    MapCreator mappaClass;

    auto values = mappaClass.getValue("value");
}

虽然这是在 MapCreator.h 中：

#pragma once
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <unordered_map>
#include<iostream>
typedef struct Data
{
    int a;
    int b;
}dataClass;

namespace bost = boost::interprocess;
typedef std::string    KeyType;
typedef dataClass MappedType;
typedef std::pair<std::string, dataClass> ValueType;
typedef bost::allocator<ValueType, bost::managed_shared_memory::segment_manager> ShmemAllocator;
typedef std::unordered_map<KeyType, MappedType, std::hash<KeyType>, std::equal_to<KeyType>, ShmemAllocator> MySHMMap;

class MapCreator
{
public:
    MySHMMap* mappa = nullptr;
    MapCreator() {
        bost::shared_memory_object::remove(nameMemory);
        bost::managed_shared_memory segment(bost::create_only, nameMemory, sizeDeclared);
        ShmemAllocator alloc_inst(segment.get_segment_manager());

        mappa = segment.construct<MySHMMap>("MySHMMapName")(alloc_inst);
        dataClass value;
        value.a = 12;
        value.b = 1111;
        mappa->insert(std::pair<std::string, dataClass>("value", value));
        std::cout << mappa->at("value").a;

    }
    dataClass getValue(std::string Key) {
        return mappa->at(Key);
    }
private:
    const int sizeDeclared = 65536;
    const char nameMemory[20] = "SharedMemoryName";
};

“cout ”在MapCreator构造函数中正确打印“12”，但是使用getValue函数，它打印上面提到的错误。

感谢您的帮助，如果您对代码有任何疑问，请提问。

信息：

• 编译器：Visual C++ 和 Visual Studio 2022
• 没有该类的代码运行良好，
• boost 类的版本是：1.78.0

Answer 1

有多个问题。

第一个是 segment 是构造函数中的局部变量，这意味着 mappa 在构造函数返回后是一个悬空指针。

其次，更大的问题是您的映射正确使用共享内存分配器，但字符串却没有。字符串也是动态分配的，因此除非您使字符串也使用共享内存，否则您的解决方案将无法工作。

开始修复：

namespace bip = boost::interprocess;
namespace bc  = boost::container;
using Segment = bip::managed_shared_memory;
using Mgr     = Segment::segment_manager;

template <typename T> using Alloc = bip::allocator<T, Mgr>;
using MyString   = bc::basic_string<char, std::char_traits<char>, Alloc<char>>;
using KeyType    = MyString;
using MappedType = dataClass;
using ValueType  = std::pair<KeyType const, MappedType>;
using MySHMMap   = std::unordered_map<KeyType, MappedType, std::hash<MyString>,
                                    std::equal_to<MyString>, Alloc<ValueType>>;

请注意，在我的编译器上，还需要在 ValueType 中使用 KeyType const。

在执行中存在额外的复杂性：segment code> 必须是一个字段，但它只能从初始化列表构造（或使用 NSMI）。这意味着我们必须让 remove 也出现在初始化列表中（在此之前）。这是我的初步尝试：

template <typename T> using Alloc = bip::allocator<T, Mgr>;
using MyString   = bc::basic_string<char, std::char_traits<char>, Alloc<char>>;
using KeyType    = MyString;
using MappedType = dataClass;
using ValueType  = std::pair<KeyType const, MappedType>;
using MySHMMap = boost::unordered_map<KeyType, MappedType, boost::hash<MyString>,
                         std::equal_to<MyString>, Alloc<ValueType>>;

class MapCreator {
  public:
    MapCreator()
        : mappa(segment.find_or_construct<MySHMMap>("MySHMMapName")(
              segment.get_segment_manager()))
    {
        mappa->emplace(MyString("value", segment.get_segment_manager()),
                       dataClass{12, 1111});
    }

    dataClass getValue(std::string key) const {
        return mappa->at(MyString(key.c_str(), segment.get_segment_manager()));
    }

  private:
    static constexpr int sizeDeclared = 65536;

    // note: declaration order defines initialization order!
    std::string_view nameMemory = "SharedMemoryName";

    struct pre_remover {
        pre_remover(const char* name)
        {
            bip::shared_memory_object::remove(name);
        }
    } pre_remove{nameMemory.data()};

    Segment segment{bip::create_only, nameMemory.data(), sizeDeclared};
    MySHMMap* mappa = nullptr;
};

注释

• 也根本没有理由为该名称分配 20 个字符的固定大小缓冲区。
• 成员声明的顺序就是它们初始化的顺序。这很重要，因为 mappa 需要位于 segment 之后，例如

我发现 std::hash 实际上并不是专门用于 MyString 实例，因为我知道我想改变这一点，无论如何我不会浪费时间来创建哈希函数对象。相反，我切换到 boost::unordered_map 以便使用 boost::hash<>

这已经可以工作Live On Coliru

打印：

12, 1111

改进

1. 作用域分配器

   allocator/get_segment_manager() 周围的事情非常笨拙。使用作用域分配器可以缓解这种情况：

   模板 <类型名称 T>
   使用 Alloc = bc::scoped_allocator_adaptor>;
   使用 MyString = bc::basic_string, Alloc>;
   使用 KeyType = MyString;
   
   模板 <类型名称 K，类型名称 V，类型名称 H = boost::hash，
             类型名 Eq = std::equal_to>;
   使用 SHMap = boost::unordered_map>>；
   
   使用 MySHMMap = SHMap;
   

   现在你可以“简单地”写：

   mappa->emplace("value", Data{12, 1111});
   

   而不是之前的复杂版本。 在 Coliru 上直播

2. 异构键查找

   在我们构造 MyString 的另一个地方（只是为了在 at() 调用之后将其丢弃...），我们可以使用 boost： :unordered_map 的兼容键查找：

   Data getValue(std::string_view key) const {
       auto it = mappa->find(key, mappa->hash_function(), mappa->key_eq());
       返回它！= mappa->end() ？它->第二
                                 ：抛出 std::range_error("getValue");
   }
   

   这需要哈希和相等性兼容：

   使用 MySHMMap = SHMap,
                          std::equal_to>;
   

   查看在 Coliru 上直播

3. 使用 C++20 标准 unordered_map 代替（请参阅https://en.cppreference.com/w/cpp/container/unordered_map/find):

   struct Hash : std::hash; {
       使用 is_transparent = std::true_type;
   };
   结构 Eq : std::equal_to {
       使用 is_transparent = std::true_type;
   };
   使用 MySHMMap = SHMap;
   

   然后：

    数据 getValue(std::string_view key) const {
   #ifdef __cpp_lib_generic_unordered_lookup
           auto it = mappa->find(key);
   ＃别的
           auto it = mappa->find(
               MyString(key.data()、key.size()、segment.get_segment_manager()));
   
   #endif
           返回它！= mappa->end() ？它->第二
                                     : 抛出 std::range_error("getValue");
       }
   

   也可以查看在 Coliru 上直播< /p>