끝에서 처음으로 C ++ 벡터 반복 i = my_vector.end();

끝에서 시작까지 벡터를 반복 할 수 있습니까?

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

또는 다음과 같은 경우에만 가능합니다.

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

답변

가장 좋은 방법은 다음과 같습니다.

for (vector<my_class>::reverse_iterator i = my_vector.rbegin();
        i != my_vector.rend(); ++i ) {
}

rbegin()/ rend()특별히 그 목적을 위해 설계되었습니다. (예, a를 증가 reverse_interator시키면 뒤로 이동합니다.)

이제 이론적으로는 방법 ( begin()/ end()& 사용 --i)이 작동 할 것입니다. std::vector반복기는 양방향이지만 end()마지막 요소는 아닙니다. 마지막 요소를 넘어서는 요소이므로 먼저 감소해야합니다. 도달하면 완료 begin()되지만 여전히 처리를해야합니다.

vector<my_class>::iterator i = my_vector.end();
while (i != my_vector.begin())
{
     --i;
    /*do stuff */

}

업데이트 : 나는 for()루프를 루프로 다시 쓰는 데 너무 공격적이었습니다 while(). (중요한 부분은이 --i시작 부분에 있다는 것 입니다.)

답변

C ++ 11이있는 경우 auto.

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

답변

폐쇄-개방 범위를 통한 역 반복을위한 잘 확립 된 “패턴”은 다음과 같습니다.

// 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
}

답변

C ++ 20부터 a std::ranges::reverse_view및 범위 기반 for 루프를 사용할 수 있습니다 .

#include<ranges>
#include<vector>
#include<iostream>

using namespace std::ranges;

std::vector<int> const vec{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for(auto& i :  views::reverse(vec)) {
    std::cout << i << ",";
}

또는 

for(auto& i :  vec | views::reverse)

불행히도 작성 시점 (2020 년 1 월)에는 주요 컴파일러가 범위 라이브러리를 구현하지 않지만 Eric Niebler의 ranges-v3에 의지 할 수 있습니다 .

#include <iostream>
#include <vector>
#include "range/v3/all.hpp"

int main() {

    using namespace ranges;

    std::vector<int> const vec{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    for(auto& i :  views::reverse(vec)) {
        std::cout << i << ",";
    }

    return 0;
}

답변

사용자 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 ++ 03 / 11에서 대부분의 표준 컨테이너에는 .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;

꽤 예쁘다고 생각합니다.

답변

역방향 반복기와 루프를 사용 rbegin()하여rend()