C++ 中的整数范围 - 当标准还没有出现时我应该怎么做？

Question

我知道 C++ 重量级人物正在努力将范围纳入语言，或者至少是标准库：

• Eric Niebler discusses ranges on his blog
• Interview with @BjarneStroustrup on his thoughts re C++17
• ISO C++ 标准委员会 (SC 22) proposal N4128 由 Niebler、Parent 和 Sutton 撰写

公平地说 - 我还没有阅读官方建议。我只是一个想要使用简单范围功能的谦虚 C++ 程序员。我应该今天做什么，而不是在 C++17 之后使用，比如说，具有步幅的简单整数范围？当然，当我开始实际使用范围时，我的要求可能会扩大，但我仍然不追求更高级的东西和各种极端情况。我想。

在更严格的方面，由于兼容性需要 (CUDA)，我正在使用一个有点旧的环境，所以我需要一些可以与 GCC 4.9.3 及其相应的标准库版本一起使用的东西，以及我可以在其中使用的东西GPU 代码（不一定是相同的库/头文件，但希望相同）。

好吧，我应该推出自己的功能有限的整数范围类型，等待手续解决 - 还是应该选择更重量级的替代品之一（Niebler 的“Ranges v3”、Boost irange 等） ?

Answer 1

编写一个简单的“索引”——一个存储类型T并通过复制返回类型O=T的输入迭代器——很容易。

我所说的index 是一个迭代器，它对支持前进和比较的事物（包括其他迭代器和类似整数的事物）进行迭代，并在取消引用时返回所包含对象的副本。生成 range-over-iterators-into-ranges 也很有用。

template<class T, class O=T>
struct index_t:
  std::iterator<
    std::input_iterator_tag,
    O, std::ptrdiff_t, O*, O
  >
{
  T t;
  explicit index_t(T&& tin):t(std::move(tin)){}
  explicit index_t(T const& tin):t(tin){}
  index_t()=default;
  index_t(index_t&&)=default;
  index_t(index_t const&)=default;
  index_t& operator=(index_t&&)=default;
  index_t& operator=(index_t const&)=default;

  O operator*()const{ return t; }
  O operator*(){ return t; }
  O const* operator->()const{ return &t; }
  O* operator->(){ return &t; }

  index_t& operator++(){ ++t; return *this; }
  index_t operator++(int){ auto r = *this; ++*this; return r; }

  friend bool operator==(index_t const& lhs, index_t const& rhs) {
    return lhs.t == rhs.t;
  }
  friend bool operator!=(index_t const& lhs, index_t const& rhs) { return !(lhs==rhs); }
};
template<class Scalar>
index_t<Scalar> index_to( Scalar s ) {
  return index_t<Scalar>(std::move(s));
}

或类似的。 index_t<int> 是一个无步长的整数迭代器。

如果我们想要跨步：

template<class T, class D=std::size_t>
struct strided {
  T t;
  D stride;
  strided( T tin, D sin ):t(std::move(tin)), stride(std::move(sin)) {}

  strided& operator++(){ t+=stride; return *this; }
  strided operator++(int){ auto r = *this; ++*this; return r; }
  operator T()&&{return std::move(t);}
  operator T() const &{return t;}

  friend bool operator==(strided const& lhs, strided const& rhs){
    return lhs.t == rhs.t;
  }
  friend bool operator!=(strided const& lhs, strided const& rhs) { return !(lhs==rhs); }
};

template<class T, class D=std::size_t>
using strided_index_t = index_t<strided<T,D>, T>;

现在你只需要写range_t<Iterator>（开始、结束、空、前、后、构造函数）。

template<class T>
strided_index_t<T> strided_index_to( T t, std::size_t d ) {
  return strided_index_t<T>( {std::move(t), d} );
}
template<class It>
struct range_t {
  It b,e;
  using element_type = decltype( *std::declval<It>() );
  It begin() const { return b; }
  It end() const { return e; }
  bool empty() const { return begin()==end(); }
  element_type front() const { return *begin(); }
  element_type back() const { return *std::prev(end()); }
};
template<class It>
range_t<It> range(It b, It e){
  return {std::move(b), std::move(e)};
}

现在我们可以设置索引范围了：

template<class Scalar>
range_t<index_t<Scalar>> index_range( Scalar b, Scalar e ) {
  return range( index_to(std::move(b)), index_to(std::move(e)) );
}
template<class Scalar>
range_t<strided_index_t<Scalar>> strided_index_range( Scalar b, Scalar e, std::size_t d ) {
  return range( strided_index_to(std::move(b), d), strided_index_to(std::move(e), d) );
}

现在我们测试：

for (int i : index_range(0, 10))
  std::cout << i << '\n';
for (int i : strided_index_range(0, 10, 2))
  std::cout << i << '\n';

boost 和其他基于范围的库中也存在类似的对象。

Live example

顺便说一句，

for( auto it : index_to( begin(vec), end(vec) ) )

以基于范围的方式迭代vec 的迭代器。写作

for( auto it : iterators_into(vec) )

也很简单。