【问题标题】:Pairwise iteration over a vector向量上的成对迭代
【发布时间】:2012-03-19 04:25:55
【问题描述】:

问题概要

给定一个std::vector<T>,我如何创建一个视图 来公开std::vector<std::pair<T, T>> 的接口,其中每一对由基础向量中的两个连续元素组成?

详情

目标是在同一存储上创建多个容器抽象,即std::vector<T>。 T 类型是某种有区别的联合,就像 Boost Variant。给出了存储要求,否则我将简单地使用std::vector<std::pair<T, T>>。我想支持的存储视图是集合(唯一元素)和表(关联数组、唯一键)。前者通过确保设置唯一性属性很简单,但后者需要处理键和值。

为了支持std::vector<T> 上的关联数组语义,我目前认为最好的方法是创建std::vector<std::pair<T, T>> 形式的视图,并且该视图将允许我使用 STL 算法来维护所需的属性.这听起来像是一个好策略吗?还有其他想法吗?

相关

如果我有一个遍历每个偶数元素的迭代器 i 和遍历每个奇数元素的迭代器 j,我会想到 Boost 的 zip iterator,这将启用(i,j) 对中的迭代。但我的用例略有不同,因为我没有两个单独的容器。

【问题讨论】:

  • 我不确定您所说的 view 是什么意思。将vector 的pair 的迭代器放入vector<T> 怎么样?或者一个自定义类来代替pair<...>,它在vector<T> 中维护一个迭代器,有时会复制该迭代器并增加它?
  • 在boost::iterator_facade 方面实现起来应该很简单。
  • 问题的最初部分似乎表明您可以简单地定义自己的 iterator 类。它将包含一个普通的vector::const_iterator 作为成员并定义operator* 使其返回一对,并定义operator++ 使其将内部迭代器递增两次。但我不明白这如何使您能够提供向量的关联数组“视图”。成对元素仍将按原始顺序排列。不会有重复数据删除或映射的概念。
  • 再次阅读后,我意识到您显然以某种方式确保存储在向量中的连续对是这样的,它们可以是关联数组的条目。 IE。每对的第一个元素是唯一的,等等。在这种情况下:您唯一需要迭代器吗?或者您是否还需要搜索键并返回值、插入新对等功能?换句话说,您是否希望实现一个基于vector 的类来实现map 的完整接口?
  • @jogojapan:是的,我实际上是在vector<T> 之上实现map,但是,不是在vector<pair<T,T>> 之上。看来我只需要定义一个自定义迭代器?!

标签: c++ stl vector iterator containers


【解决方案1】:

看来Boost的iterator_facade确实是我想要的。这是一个玩具示例(边缘粗糙):

#include <algorithm>
#include <iostream>
#include <vector>
#include <boost/iterator/iterator_facade.hpp>

template <typename Value>
class pair_iterator
  : public boost::iterator_facade<
        pair_iterator<Value>
      , Value
      , boost::random_access_traversal_tag
      , std::pair<Value&, Value&>
      , typename std::vector<Value>::difference_type
    >
{
public:
    typedef std::vector<Value> vector_type;
    typedef typename vector_type::difference_type difference_type;
    typedef typename vector_type::iterator iterator;

    pair_iterator()
        : i_(0)
    {
    }

    explicit pair_iterator(iterator i)
      : i_(i)
    {
    }

private:
    friend class boost::iterator_core_access;

    bool equal(pair_iterator<Value> const& other) const
    {
        return i_ == other.i_;
    }

    void increment()
    {
        ++i_;
        ++i_;
    }

    std::pair<Value&, Value&> dereference() const
    {
        return { std::ref(*i_), std::ref(*(i_ + 1)) };
    }

    void advance(difference_type n)
    {
        i_ += n << 1;
    }

    difference_type distance_to(pair_iterator<Value> const& other) const
    {
        return other.i_ - i_;
    }

    iterator i_;
};

int main()
{
    typedef pair_iterator<int> int_map_iterator;
    std::vector<int> v{2, 20, 3, 30, 5, 50, 7, 70};
    int_map_iterator first(v.begin());
    int_map_iterator last(v.end());

    std::for_each(first + 1, last,
                  [](std::pair<int&, int&> p)
                  {
                      std::cout
                          << p.first << " -> "
                          << p.second << std::endl;
                  });

    return 0;
}

输出是:

3 -> 30
5 -> 50
7 -> 70

问题

  • 此示例尚未解决从 iterator 到 const_iterator 的转换。
  • 迭代器仅在底层向量大小均匀且需要更保守的 dereference() 实现时才起作用。

【讨论】:

  • 当向量大小为奇数时,这看起来会崩溃。
  • 没错,谢谢指出。可以在迭代器构造函数中检查 size % 2 或使用更安全的解引用运算符。
【解决方案2】:

首先要注意的是,您将无法公开std::pair&lt;T const, T&gt;&amp; 作为修改对象的方法。然而,可能足够接近的是std::pair&lt;T const, T&amp;&gt;,因为您只能更改第二部分。

有了这个,你似乎需要

  1. 一种迭代器类型,它跳过所有其他值并用于迭代键(具有偶数索引的元素)和值(具有奇数索引的元素)。
  2. 类似于“zip 迭代器”的东西,它接受两个迭代器并公开从它们获得的 std::pair&lt;T const, T&amp;&gt;。

【讨论】:

  • 您介意详细说明std::pair&lt;T const, T&amp;&gt; 的需求吗?这是map-like 容器的要求吗?
  • 好吧,您希望能够使用类似it-&gt;second = ... 的方式更改值,整个密钥是不可变的。同样,m[key] 之类的东西应该可以工作。
  • 我明白了。提供std::pair&lt;T const&amp;, T&amp;&gt; 是否足够,即通过引用获取密钥?
  • 是的,我认为这应该没问题:您也不想复制密钥。 “普通”贴图返回您不会给出的 std::pair&lt;Key const, Value&gt;&amp;。它只是试图给它兼容的访问权限。
猜你喜欢
  • 2014-10-25
  • 2017-08-29
  • 1970-01-01
  • 2020-01-03
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2019-01-16
  • 1970-01-01
相关资源
最近更新 更多