带有 std::pair 键的 std::map ，其中对元素没有顺序重要性

Question

正如问题所说，我需要以这样的方式使用 std::map。

std::map<std::pair<int, int>, int*> m;

int* a_ptr = new int;
*a_ptr = 15;
m[std::make_pair(1, 2)] = a_ptr;
std::cout << *m[std::make_pair(2, 1)] << std::endl; //should output 15

现在，在我的实际实现中，所有键和值实际上都是指针。我应该如何解决这个问题？

我想到了两个想法。

1. 一个是我应该写一个函数，每次我使用m[] 访问或写入地图，我也应该m.find()检查 其他对组合并照此行事。

2. Other 正在使用带有自定义哈希的 std::unordered_map 当pair 的元素位置被切换时，不知何故没有区别。 （我不知道该怎么做，如果我乘以或添加 两个指针的结果将不相等。如果这是需要一些帮助 要走的路。）

如果您能想到更好的方法，我会很高兴听到它，否则我已经在第二条中说明了我需要帮助的地方。 （我觉得效率更高，第一个不好看）

谢谢。

Answer 1

您能否简单地确保这些对始终保持相同的顺序？使用辅助函数，例如：

std::pair<int,int> my_make_pair(int a, int b) 
{
    if ( a < b ) return std::pair<int,int>(a,b);
    else return std::pair<int,int>(b,a);
}

并始终使用它来访问地图：

m[my_make_pair(1,2)] = a_ptr;
std::cout << m[my_make_pair(2, 1)] << std::endl;

Answer 2

只需使用自定义比较器

[](std::pair<int, int> const& lhs, std::pair<int, int> const& rhs) {
   int lhs_min = std::min(lhs.first, lhs.second);
   int lhs_max = std::max(lhs.first, lhs.second);
   int rhs_min = std::min(rhs.first, rhs.second);
   int rhs_max = std::max(rhs.first, rhs.second);

   return lhs_min < rhs_min || (!(rhs_min < lhs_min) && lhs_max < rhs_max)
}

这是如何工作的？

前几行确定性地对一对中的两个元素进行排序；也就是说，您可以按任意顺序提供它们，lhs_min 和 lhs_max 将是相同的。然后，我们对结果使用标准等效技术。所有整数副本都将由编译器优化，min/max 将被内联。

请注意，我使用 C++11 的 lambdas 是为了方便输入，但后来发现没有很好的方法可以将它们用作 std::map 的比较器，因此您必须正确编写函子。

Answer 3

template<typename T, typename PairCmp = std::less<std::pair<T,T>> >
struct symmetric_pair_sort {
  bool operator()( std::pair<T,T> const& left, std::pair<T,T> const& right ) const {
    if (left.second<left.first) {
      return (*this)(std::make_pair( left.second, left.first ), right );
    }
    if (right.second<right.first) {
      return (*this)(left, std::make_pair( right.second, right.first ) );
    }
    return PairCmp()(left, right);
  }
};

// or, the far bulkier yet more efficient:
template<typename T, typename PairCmp = std::less<std::pair<T&, T&>> >
struct symmetric_pair_sort {
  template<bool left_reversed, bool right_reversed>
  bool Helper( std::pair<T,T> const& left, std::pair<T,T> const& right ) const {
    std::pair<T&, T&> left_ordered( left_reversed?left.first:left.second, left_reversed?left.second:left.first );
    std::pair<T&, T&> right_ordered( right_reversed?right.first:right.second, right_reversed?right.second:right.first );
    return PairCmp()( left_ordered, right_ordered );
  }
  bool operator()( std::pair<T,T> const& left, std::pair<T,T> const& right ) const {
    if (left.second<left.first) {
      if (right.second<right.first) {
        return Helper<true, true>(left, right);
      } else {
        return Helper<true, false>(left, right);
      }
    } else {
      if (right.second<right.first) {
        return Helper<false, true>(left, right);
      } else {
        return Helper<false, false>(left, right);
      }
  }
};

std::map<std::pair<int, int>, int*, symmetric_pair_sort<int> > m;

Answer 4

另一种解决方案是使用std::set<int> 而不是std::pair<int,int>。 Sets 存储有序的数据，因此无需订购您的配对，因此准确地满足您的要求。

另一方面，使用明确排序对的比较包装器的其他答案可能更实用。