Question

今天早上我正在写一个算法，我遇到了一个奇怪的情况。我有两个std::map个。我想在每个键的各组键上执行一组交集（找到两个键共有的键）。在未来的某个时刻，我认为我也可能也希望在这里执行set减法。幸运的是，STL包含了这两种操作的功能。问题是，我似乎无法从std::set获得std::map个密钥。有没有办法做到这一点？我正在寻找一些简单的东西，就像在Java中一样：

std::set<Foo> keys = myMap.getKeySet();

我的理解是我不能直接在迭代器上使用std::set_intersection()函数到地图中，因为地图会显示std::pair个对象而不仅仅是键。此外，我不认为地图保证顺序。我也有兴趣在一对std::multimap上执行相同的操作，如果这有任何区别的话。

编辑：我最初忘了提到由于我被迫使用的编译器的年龄（MSVC ++ 6），在boost中可用的大多数漂亮的模板技巧都不能使用

Answer 1

你基本上想要的是一个副本，因为std :: map不会将密钥保存在std :: set中。 std :: copy假定值类型是兼容的，这不是这里的情况。 std :: map :: value_type是一个std :: pair。您只想复制该对的第一部分，这意味着您需要一个std :: transform。现在，由于您将在集合上使用insert_iterator，因此顺序无关紧要。即使地图已经排序，std :: set也会对插入进行排序。

[编辑]代码可能更容易。我的头脑，没有编译。

std::transform(MyMap.begin(), MyMap.end(),
    std::inserter(MySet, MySet.end()),
    boost::bind(&std::pair<Key,Value>::first, _1));

如果您有SGI的select1st，则不需要boost :: bind。

[编辑] 针对C ++ 14进行了更新

std::transform(MyMap.begin(), MyMap.end(),
    std::inserter(MySet, MySet.end()),
    [](auto pair){ return pair.first; });

Answer 2

地图确保保证订单;这就是为什么它被称为sorted associative container。您可以将set_intersection与自定义比较器函数一起使用，第二个变体列为here。

所以，像

bool your_less(const your_map::value_type &v1, const your_map::value_type &v2)
{ return v1.first < v2.first; }

set_intersection(m1.begin(), m1.end(), m2.begin(), m2.end(), your_output_it, your_less);

应该做的伎俩。（也可以使用boost :: lambda和bind来避免编写临时函数。）

默认运算符＆lt; over pairs比较两个组件。由于您只需要在对的第一部分（映射键）上进行等效，因此您需要定义自己的比较运算符来提供这种关系（这是上面的函数所做的）。

Answer 3

在实践中，

yourmap::const_iterator mi;
set<key_type> k;
for (mi = yourmap.begin(); mi != yourmap.end(); ++mi)
  k.insert(mi->first);
return k;

Answer 4

您可以使用通用的boost :: transform_iterator返回仅返回键（而不是值）的迭代器。见How to retrieve all keys (or values) from a std::map and put them into a vector?

Answer 5

最好的非SGI，非升级STL算法友好的解决方案是扩展map :: iterator，如下所示：

template<typename map_type>
class key_iterator : public map_type::iterator
{
public:
    typedef typename map_type::iterator map_iterator;
    typedef typename map_iterator::value_type::first_type key_type;

    key_iterator(const map_iterator& other) : map_type::iterator(other) {} ;

    key_type& operator *()
    {
        return map_type::iterator::operator*().first;
    }
};

// helpers to create iterators easier:
template<typename map_type>
key_iterator<map_type> key_begin(map_type& m)
{
    return key_iterator<map_type>(m.begin());
}
template<typename map_type>
key_iterator<map_type> key_end(map_type& m)
{
    return key_iterator<map_type>(m.end());
}

然后像这样使用它们：

        map<string,int> test;
        test["one"] = 1;
        test["two"] = 2;

        set<string> keys;

//      // method one
//      key_iterator<map<string,int> > kb(test.begin());
//      key_iterator<map<string,int> > ke(test.end());
//      keys.insert(kb, ke);

//      // method two
//      keys.insert(
//           key_iterator<map<string,int> >(test.begin()),
//           key_iterator<map<string,int> >(test.end()));

        // method three (with helpers)
        keys.insert(key_begin(test), key_end(test));

Answer 6

您可以迭代并将每个键添加到一个集合中。集合和映射都是有序的，无序变量不是。

Answer 7

我找到了您的问题here

的良好链接

并为您的问题提供一些代码：

    #include <iostream>
    #include <map>
    #include <set>
    #include <iterator>

    typedef std::map<std::string, int> MyMap;

    // also known as select1st in SGI STL implementation
    template<typename T_PAIR>
    struct GetKey: public std::unary_function<T_PAIR, typename T_PAIR::first_type>
    {
        const typename T_PAIR::first_type& operator()(const T_PAIR& item) const
        {
            return item.first;
        }
    };

    int main(int argc, char** argv)
    {
        MyMap m1,m2;

        m1["a"] = 1;
        m1["b"] = 2;
        m2["c"] = 3;
        m2["b"] = 3;

        std::set<std::string> s;
        std::transform(m1.begin(), m1.end(), std::inserter(s, s.begin()), GetKey<MyMap::value_type>());
        std::transform(m2.begin(), m2.end(), std::inserter(s, s.begin()), GetKey<MyMap::value_type>());
        std::copy(s.begin(), s.end(), std::ostream_iterator<std::string>(std::cout, " "));
        std::cout << std::endl;
        return 0;
    }

Answer 8

您也许可以为地图创建一个迭代器，它只使用boost :: adapters :: map_key生成键，请参阅boost::adapters::map_key documentation中的示例。这似乎是在Boost 1.43中引入的，并且应该与C ++ 2003兼容，但我不知道VC ++ 6是否具体，这是来自C ++ 98时代。

Answer 9

从zvrba的答案和dianot的评论中建立起来：

只需使接收集合成为对的矢量而不是地图，而dianot指出的问题就结束了。所以，使用zvrba示例：

std::vector<std::pair<keytype, valtype>> v;

set_intersection(m1.begin(), m1.end(), m2.begin(), m2.end(),
std::back_inserter(v), []( std::pair<keytype, valtype> const & a,
std::pair<keytype, valtype> const & b){return a.first < b.first;});

因此，如果不构建中间副本或集合，我们可以有效地获得两个映射的交集。这个结构用gcc5.3编译。

如何获得std :: map的std ::键集

9 个答案: