c++ - 追加 - 配列 要素数




終わりから始まりまでのC++ベクトルの反復 (5)

C++11お持ちの場合は、 autoを使用することができます。

for (auto it = my_vector.rbegin(); it != my_vector.rend(); ++it)
{
}

終わりから始まりに向かってベクトルを反復することは可能ですか?

for (vector<my_class>::iterator i = my_vector.end();
        i != my_vector.begin(); /* ?! */ ) {
}

あるいは、それはそのようなものでのみ可能です:

for (int i = my_vector.size() - 1; i >= 0; --i) {
}

このコードを使用する

//print the vector element in reverse order by normal iterator.
cout <<"print the vector element in reverse order by normal iterator." <<endl;
vector<string>::iterator iter=vec.end();
--iter;
while (iter != vec.begin())
{
    cout << *iter  << " "; 
    --iter;
}

クローズド・オープン・レンジで逆反復するための十分に確立された「パターン」は、次のようになります

// Iterate over [begin, end) range in reverse
for (iterator = end; iterator-- != begin; ) {
  // Process `*iterator`
}

または、もしあなたが好きなら、

// Iterate over [begin, end) range in reverse
for (iterator = end; iterator != begin; ) {
  --iterator;
  // Process `*iterator`
}

このパターンは、たとえば、符号なしインデックスを使用して配列を逆索引付けする場合に使用できます

int array[N];
...
// Iterate over [0, N) range in reverse
for (unsigned i = N; i-- != 0; ) {
  array[i]; // <- process it
}

(このパターンに精通していない人は、符号なし整数型を使用て配列インデックスを作成することを強く主張しています。これは、

これは、「スライディングポインタ」技術を使用して配列を反復処理するために使用できます

// Iterate over [array, array + N) range in reverse
for (int *p = array + N; p-- != array; ) {
  *p; // <- process it
}

通常の(逆ではない)イテレータを使用してベクトル上の逆反復に使用することができます

for (vector<my_class>::iterator i = my_vector.end(); i-- != my_vector.begin(); ) {
  *i; // <- process it
}

ユーザーのrend() / rbegin()イテレータ:

for (vector<myclass>::reverse_iterator it = myvector.rbegin(); it != myvector.rend(); it++)


template<class It>
std::reverse_iterator<It> reversed( It it ) {
  return std::reverse_iterator<It>(std::forward<It>(it));
}

次に:

for( auto rit = reversed(data.end()); rit != reversed(data.begin()); ++rit ) {
  std::cout << *rit;

あるいは、C ++ 14では、次のようにします。

for( auto rit = std::rbegin(data); rit != std::rend(data); ++rit ) {
  std::cout << *rit;

C ++ .rbegin() 、ほとんどの標準コンテナに.rbegin().rend()メソッドもあります。

最後に、次のようにレンジアダプタをbackwards書くことができます:

namespace adl_aux {
  using std::begin; using std::end;
  template<class C>
  decltype( begin( std::declval<C>() ) ) adl_begin( C&& c ) {
    return begin(std::forward<C>(c));
  }
  template<class C>
  decltype( end( std::declval<C>() ) ) adl_end( C&& c ) {
    return end(std::forward<C>(c));
  }
}

template<class It>
struct simple_range {
  It b_, e_;
  simple_range():b_(),e_(){}
  It begin() const { return b_; }
  It end() const { return e_; }
  simple_range( It b, It e ):b_(b), e_(e) {}

  template<class OtherRange>
  simple_range( OtherRange&& o ):
    simple_range(adl_aux::adl_begin(o), adl_aux::adl_end(o))
  {}

  // explicit defaults:
  simple_range( simple_range const& o ) = default;
  simple_range( simple_range && o ) = default;
  simple_range& operator=( simple_range const& o ) = default;
  simple_range& operator=( simple_range && o ) = default;
};
template<class C>
simple_range< decltype( reversed( adl_aux::adl_begin( std::declval<C&>() ) ) ) >
backwards( C&& c ) {
  return { reversed( adl_aux::adl_end(c) ), reversed( adl_aux::adl_begin(c) ) };
}

今、あなたはこれを行うことができます:

for (auto&& x : backwards(ctnr))
  std::cout << x;

私はかなり可愛いと思います。







iterator