我知道 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 代码(不一定是相同的库/ header ，但希望相同)。

好吧，我应该推出自己的功能有限的整数范围类型，等待手续解决 - 或者我应该选择一种更重量级的替代方案(Niebler 的“Ranges v3”、Boost irange 等) ？

最佳答案

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

我称之为 index是支持推进和比较的事物的迭代器(包括其他迭代器和类似整数的事物)，并在取消引用时返回所包含对象的拷贝。生成 ranges-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) )

也很简单。

关于c++ - C++ 中的整数范围——当标准还不存在时我该怎么办？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35937616/