c++ - 为 vector 的 vector 提供平坦迭代器的优雅方式

Question

我有一个适配器，其目标是为对值提供前向迭代器 pair<FeatureVector, Label> .但是在我的内部表示中，我将数据存储为 vector<pair<vector<strings>, Label>> .

因此在迭代期间，我需要将其展平并转换每个 string ，这是像“oil drops massively today”这样的短句，到FeatureVector

在原始变体中，我有类似的东西:

{
  {"Oil drops massively","OPEC surge oil produciton","Brent price goes up" -> "OIL_LABEL"}, 
  {"France consume more vine", "vine production in Italy drops" -> "VINE_LABEL"}
}

我需要将其转换为:

{
  vectorize("Oil drops massively") -> "OIL_LABEL", 
  vectorize("OPEC surge oil produciton") -> "OIL_LABEL", ... , 
  vectorize("vine production in Italy drops") -> "VINE_LABEL"
}

vectorize() -> 这是一个从句子到稀疏 vector 的转换 "Oil drops on NYSE" -> {0,1,0..0,1,0..0,1}

最简单的方法是创建新 vector 并使用所有数据对其进行初始化，而不是使用它的迭代器，但这是非常耗资源的操作，因此理想情况下我希望在每次迭代时都进行这种转换。这种转换最优雅的方式是什么？

这是用于存储文本语料库的数据结构的简化版本。后面的分类器初始化需要用到迭代器，需要2个迭代器:begin和 end这在逻辑上与 vector 中的相同.

Answer 1

一个简单的范围类型:

template<class It>
struct range_t {
  It b{},e{};
  It begin() const {return b;}
  It end() const {return e;}
  bool empty() const {return begin()==end();}
  friend bool operator==(range_t lhs, range_t rhs){
    if (lhs.empty() && rhs.empty()) return true;
    return lhs.begin() == rhs.begin() && lhs.end() == rhs.end();
  }
  friend bool operator!=(range_t lhs, range_t rhs){
    return !(lhs==rhs);
  }
  range_t without_front( std::size_t N = 1 ) const {
    return { std::next(begin(), N), end() };
  }
  range_t without_back( std::size_t N = 1 ) const {
    return { begin(), std::prev(end(),N) };
  }
  decltype(auto) front() const {
    return *begin();
  }
  decltype(auto) back() const {
    return *std::prev(end());
  }
};
template<class It>
range_t<It> range( It b, It e ) {
  return {b,e};
}

这是一个不兼容的伪迭代器，它执行两个 ranes 的叉积:

template<class ItA, class ItB>
struct cross_iterator_t {
  range_t<ItA> cur_a;
  range_t<ItB> orig_b;
  range_t<ItB> cur_b;

  cross_iterator_t( range_t<ItA> a, range_t<ItB> b ):
    cur_a(a), orig_b(b), cur_b(b)
  {}

  bool empty() const { return cur_a.empty() || cur_b.empty(); }

  void operator++(){
    cur_b = cur_b.without_front();
    if (cur_b.empty()) {
      cur_a = cur_a.without_front();
      if (cur_a.empty()) return;
      cur_b = orig_b;
    }
  }
  auto operator*()const {
    return std::make_pair( cur_a.front(), cur_b.front() );
  }
  friend bool operator==( cross_iterator_t lhs, cross_iterator_t rhs ) {
    if (lhs.empty() && rhs.empty()) return true;

    auto mytie=[](auto&& self){
      return std::tie(self.cur_a, self.cur_b);
    };
    return mytie(lhs)==mytie(rhs);
  }
  friend bool operator!=( cross_iterator_t lhs, cross_iterator_t rhs ) {
    return !(lhs==rhs);
  }
};
template<class Lhs, class Rhs>
auto cross_iterator( range_t<Lhs> a, range_t<Rhs> b )
-> cross_iterator_t<Lhs, Rhs>
{
  return {a,b};
}

从这里你可以得到std::vector<A>, B并做:

template<class A, class B>
auto cross_one_element( A& range_a, B& b_element ) {
  auto a = range( std::begin(range_a), std::end(range_a) );
  auto b = range( &b_element, (&b_element) +1 );
  auto s = cross_iterator(a, b);
  decltype(s) f{};
  return cross_iterator(s, f);
}

这样就解决了您的一个问题。需要修复以上内容以支持真正的输入迭代器功能，而不仅仅是上面与 for(:) 一起使用的伪迭代器。 .

然后您必须编写代码，获取 X 的 vector 并将其转换为 f(X) 范围内的某个函数 f。

然后您必须编写代码，获取一系列范围，并将其展平为一个范围。

这些步骤中的每一个都不比上面的步骤难。

有些图书馆可以为您做这件事。 boost 有一些，Rangesv3 有一些，还有一堆其他范围操作库。

Boost 甚至允许您通过指定对 * 执行的操作来编写迭代器以及接下来和== .当您的一个子 vector 为空时如何处理仍然很棘手，因此在这种情况下使用更通用的算法可能是明智的。

上面的代码未经测试，是 C++14。 C++11 版本只是更冗长。