c++ - 使用 unordered_set_of 和自定义类型 boost bimap

Question

我想使用 bimap 在自定义类之间创建双向映射，这就是我所做的(A 类和 B 类是简化，它们不只存储整数):

class A
{
    private:
        int value1;
        int value2;
    public:
        int get_value1() const { return this->value1;}
        int get_value2() const { return this->value2;}
        A(int value1, int value2): value1(value1), value2(value2) {};
};

struct AHash
{
    size_t operator()(const A& a) const {
        size_t seed = 0;
        hash_combine(seed, a.get_value1());
        hash_combine(seed, a.get_value2());
        return seed;
    }
};

struct AComp
{
    bool operator()(const A& lhs, const A& rhs) const {
        return lhs.get_value1() == rhs.get_value1() &&
               lhs.get_value2() == rhs.get_value2();
    }
};

B 类与 A 相同，然后我创建了 map :

typedef bimap< 
   unordered_set_of<A, AHash, AComp>,
   unordered_set_of<B, BHash, BComp> 
   > CustomMap;

CustomMap my_map; 

它编译但崩溃，没有有意义的日志。

关于我做错了什么的任何线索？

顺便说一句:我正在使用 c++03

Answer 1

我怀疑你有undefined behaviour elsewhere (例如内存管理，或实际类型 A 和 B)。这是我自己的独立测试，基于您的样本，其中包含大量随机插入和查找:

Live On Coliru

#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/bimap.hpp>
#include <boost/bimap/unordered_set_of.hpp>
#include <iostream>

#include <boost/random.hpp> // for test
#include <boost/range/empty.hpp>
#include <boost/range/iterator_range.hpp>

template <typename>
class Obj
{
  private:
    int value1;
    int value2;
    boost::tuple<int const&, int const&> key() const { return boost::tie(value1, value2); }
  public:
    int get_value1() const { return this->value1;}
    int get_value2() const { return this->value2;}
    Obj(int value1, int value2): value1(value1), value2(value2) {};

    struct Hash {
        size_t operator()(const Obj& a) const {
            size_t seed = 0;
            boost::hash_combine(seed, a.get_value1());
            boost::hash_combine(seed, a.get_value2());
            return seed;
        }
    };

    struct Equality {
        bool operator()(const Obj& lhs, const Obj& rhs) const {
            return lhs.key() == rhs.key(); 
        }
    };
};

typedef Obj<struct TagA> A;
typedef Obj<struct TagB> B;

int myrandom() {
    static boost::mt19937 prng(42);
    static boost::uniform_int<> dist(0, 1000);
    return dist(prng);
}

int main() {

    typedef boost::bimaps::bimap< 
            boost::bimaps::unordered_set_of<A, A::Hash, A::Equality>,
            boost::bimaps::unordered_set_of<B, B::Hash, B::Equality> 
        > CustomMap;

    CustomMap map;

    int dupes = 0;
    for (int i=0; i < 10000; ++i)
    {
        A a(myrandom(), myrandom());
        B b(myrandom(), myrandom());

        if (!map.insert(CustomMap::value_type(a, b)).second)
            ++dupes;
    }

    std::cout << dupes << " duplicate insertions were skipped\n";

    int left_hits = 0;
    for (int i=0; i <= 10000; ++i)
        if (!boost::empty(boost::make_iterator_range(map.left.equal_range(A(i,i)))))
            ++left_hits;

    int right_hits = 0;
    for (int i=0; i <= 10000; ++i)
        if (!boost::empty(boost::make_iterator_range(map.right.equal_range(B(i,i)))))
            ++right_hits;

    std::cout << "Random hits (left, right): (" << left_hits << ", " << right_hits << ")\n";
}

打印(对于给定的种子和随机实现):

112 duplicate insertions were skipped
Random hits (left, right): (11, 7)

即使在优化构建中，它也能在 valgrind 下正常运行。