地图的联合迭代器？

Question

[前言： 像std::map 这样的关联 C++ 容器有点像只有一个键列的微型数据库。 Boost 的 bimap 将其提升为一个两列并在两列中查找的表，但这只是类比的范围——没有“polymap”可以概括这个想法。]

无论如何，我想继续将地图视为数据库，现在我想知道是否有一个迭代器（或其他解决方案）可以让我对几个组成地图进行 UNION。也就是说，所有映射都具有相同的类型（或值类型和比较器，至少），我想要一个将整个集合视为一个大的多重映射的迭代器（重复键是可以的）并让我在正确的联合中遍历它顺序。

这样的事情是否存在，也许在 Boost 中？还是很容易装一个？在伪代码中：

std::map<K, M> m1, m2;
union_iterator<K, M> u(m1, m2)
for(auto it = u.begin(); it != u.end(); ++it) { /* ... */ }

例如，如果我们有：

m1 = { { 9:00, "Check in"}, { 12:00, "Break" }, { 16:00, "Check out"} };
m2 = { { 10:30, "coffee" }, { 12:15, "baked beans" }, { 15:00, "lies" } };

然后我希望迭代器产生：

9:00, "Check in"; 10:30, "coffee"; 12:00, "Break"; 12:15, "baked beans"; ...

Answer 1

有一个“polymap”：Boost.MultiIndex。

Answer 2

将mapS 复制到临时文件中，将一个附加到另一个（以防您可以修改它们）或使用vector 作为临时文件std::set_union 和自定义比较器是最简单的替代解决方案。

Answer 3

还是很容易安装一个？

装配应该相当容易：对于 N 个基本映射，您的迭代器包含一个优先级队列，该队列由基本迭代器指向的元素的 N 个键进行优先级排序。对于取消引用，取消引用队列前面的迭代器。对于增量，在队列前面增加迭代器，如果它的增量不在末尾，则重新插入它。

Answer 4

这很容易做到：

template<class It>
class union_iterator
{
public:
  union_iterator(It it1_begin, It it1_end, It it2_begin, It it2_end)
     : current1(it1_begin), current2(it2_begin), end1(it1_end), end2(it2_end)
     { if (it1_begin != it1_end && it2_begin != it2_end) {
         if (*it1_begin < *it2_begin) { current= &current1; }
         else { current = &current2; }
       } else if (it1_begin==it1_end) { current=&current2; }
       else { current = &current1; }
     }
  void operator++() { 
    if (current1!=end1 && current2 !=end2) { 
       if (*current1 < *current2) 
         { ++current1; current = &current1; } 
         else { ++current2; current=&current2; } 
    } else if (current1==end1 && current2 != end2) {
       ++current2;
       current = &current2;
    } else if (current1!=end1 && current2 == end2) {
       ++current1;
       current = &current1;
    }
  }
  typename std::iterator<It1>::value_type operator*() { return **current; }
private:
  It current1;
  It current2;
  It end1;
  It end2;
  It *current;
};

但真正的问题是实现普通迭代器所需的所有剩余成员函数:-)。 Boost 有一些库可以帮助你做到这一点，但它可能仍然相当困难。

Answer 5

这不是您要求的迭代器，但我刚刚在标准库中找到了这个函数：

§ 25.4.5.2 set_union [set.union]

 template<class InputIterator1, class InputIterator2,
 class OutputIterator, class Compare>
 OutputIterator
 set_union(InputIterator1 first1, InputIterator1 last1,
 InputIterator2 first2, InputIterator2 last2,
 OutputIterator result, Compare comp);

1. 效果：构造两个范围内元素的排序交集；也就是说，两个范围内都存在的元素集。
2. 要求：结果范围不得与任何一个原始范围重叠。
3. 返回：构造范围的结束。
4. 复杂性：最多 2 * ((last1 - first1) + (last2 - first2)) - 1 次比较。
5. 备注：如果 [first1,last1) 包含 m 个彼此等价的元素，而 [first2, last2) 包含 n 个与其等价的元素，则应从第一个元素复制前 min(m, n) 个元素范围到输出范围，按顺序。

还有std::set_intersection、std::set_difference和std::set_symmetric_difference

Answer 6

这是我将如何实现 thiton 的答案：

template <class container> class union_iterator
{
private:
    typedef std::pair<typename container::const_iterator, typename container::const_iterator> container_range;
    class container_range_compare
    {
    public:
        bool operator()(const container_range &lhs, const container_range &rhs) const
        {
            return typename container::value_compare()(*lhs.first, *rhs.first);
        }
    };

    std::priority_queue<container_range, container_range_compare> m_range_queue;
    container::const_iterator m_current_iterator;
    bool m_is_valid;

    void add_container(const container &cont)
    {
        add_container_range(std::make_pair(cont.begin(), cont.end()));
    }

    void add_container_range(const container_range &range)
    {
        if (range.first!=range.second)
        {
            m_range_queue.push(range);
        }
    }

public:
    union_iterator(const container &a): m_valid(false)
    {
        add_container(a);
    }

    bool next()
    {
        m_is_valid= false;

        if (!m_range_queue.empty())
        {
            container_range range= m_range_queue.pop();
            m_current_iterator= range.first;

            ++range.first;
            add_container_range(range);

            m_is_valid= true;
        }

        return m_is_valid;
    }

    typename const container::value_type &operator *() const
    {
        return *m_current_iterator;
    }

    typename const container::value_type *operator ->() const
    {
        return m_current_iterator.operator ->();
    }
};

它的用法与union_iterator<K, V> 略有不同，但它实现了基本思想。您可以扩展构造函数以接受多个适合您的映射，并在while (iterator.next()) 循环而不是for (...) 循环中使用它。

编辑：我通过一次完成所有弹出和推送来简化了next()。所以现在更简单了！ （也可以花费一些精力使它像一个 STL 迭代器，但这会变得乏味。）

Answer 7

作为我announced，我得到了一些很酷的东西。

我现在发布它，因为我不确定今晚是否能及时回来发布它。我将花几句话解释一下。 （在这篇文章中）

PS. 包含将被削减（约 20%）；我可能也会对代码做一些更一般的工作。

关于这段代码可以说很多：它不是很有效，也不是很干净（还）。然而，它几乎是无限通用的，应该像其他任何东西一样扩展。所有代码都可以在 github gist 中找到：

• merge_maps_iterator.hpp
• Makefile
• test.cpp - 一组相当神秘的测试用例展示了通用性
  _{（我并不是说用整数和浮点数作为键的映射是一个好主意 （更不用说两者同时进行了）-只是表明可以做到）}

这是你可以找到的 test.cpp 的输出：

 == input ========================================
{ 2, aap }      { 23, mies }    { 100, noot }   { 101, broer }  
{ b, 3.14 }     
 == output =======================================
     2: aap;
    23: mies;
    98: 3.14;
   100: noot;
   101: broer;

 == input ========================================
{ b, 3.14 }     
{ 2, aap }      { 23, mies }    { 100, noot }   { 101, broer }  
 == output =======================================
     2: aap;
    23: mies;
    98: 3.14;
   100: noot;
   101: broer;

 == input ========================================
{ 2, aap }      { 23, mies }    { 100, noot }   { 101, broer }  
{ 2, aap }      { 23, mies }    { 100, noot }   { 101, broer }  
 == output =======================================
     2: aap;aap;
    23: mies;mies;
   100: noot;noot;
   101: broer;broer;

 == input ========================================
{ b, 3.14 }     
{ b, 3.14 }     
 == output =======================================
     b: 3.14;3.14;

 == input ========================================
{ 1.0, dag }    { 22.0, bye }   { 24.0, Tschüß }
{ 1, true }     { 22, false }   { 24, true }    
{ b, 3.14 }     
{ 2, aap }      { 23, mies }    { 100, noot }   { 101, broer }  
 == output =======================================
   1.0: dag;true;
   2.0: aap;
  22.0: bye;false;
  23.0: mies;
  24.0: Tschüß;true;
  98.0: 3.14;
 100.0: noot;
 101.0: broer;

 == input ========================================
{ 1.0, dag }    { 2.0, EXTRA }  { 22.0, bye }   { 24.0, Tschüß }
{ 1, true }     { 22, false }   { 24, true }    
{ b, 3.14 }     
{ 2, aap }      { 23, mies }    { 100, noot }   { 101, broer }  
 == output =======================================
   1.0: dag;true;
   2.0: EXTRA;aap;
  22.0: bye;false;
  23.0: mies;
  24.0: Tschüß;true;
  98.0: 3.14;
 100.0: noot;
 101.0: broer;

Answer 8

使用 boost function_output_iterator 的非常简单的解决方案：

typedef std::map< std::string, std::string > Map;
Map first_map, second_map;
... // fill maps
// iterate over maps union
std::merge(
            first_map.begin(), first_map.end(),
            second_map.begin(), second_map.end(),
            boost::make_function_output_iterator(
                []( const Map::value_type & pair )
                {
                    std::cout << 
                    "key = " << pair.first << 
                    "; value = " << pair.second << std::endl;
                }       
            ),
            first_map.value_comp()
    );

我们可以通过使用 boost::set_union（范围版本）而不是 std::set_union 使这个解决方案更漂亮。

UPD 更新版本使用不同的键/值类型：

typedef std::map< int, char > FirstMap;
typedef std::map< short, std::string > SecondMap;
FirstMap        first_map;
SecondMap       second_map;

... // fill maps

struct CustomOutput
{
    void operator()( const FirstMap::value_type & pair ) const
    {
        std::cout << "key = " << pair.first <<
        "; value = " << pair.second << std::endl;
    }

    void operator()( const SecondMap::value_type & pair ) const
    {
        std::cout << "key = " << pair.first <<
        "; value = " << pair.second << std::endl;
    }
};

struct CustomPred
{
    bool operator()( const FirstMap::value_type & first_pair, const SecondMap::value_type & second_pair ) const
    { return first_pair.first < second_pair.first; }

    bool operator()( const SecondMap::value_type & second_pair, const FirstMap::value_type & first_pair ) const
    { return second_pair.first < first_pair.first; }
};

// iterate over maps union
std::merge(
            first_map.begin(), first_map.end(),
            second_map.begin(), second_map.end(),
            boost::make_function_output_iterator( CustomOutput() ),
            CustomPred()
    );

UPD2 std::set_union 替换为 std::merge