Итерация вектора С++ с конца до начала

Ответ 1

Лучший способ это:

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

rbegin()/rend() были специально разработаны для этой цели. (И да, увеличение 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 находится в начале.)

Ответ 2

Если у вас есть С++ 11, вы можете использовать auto.

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

Ответ 3

Хорошо зарекомендовавший себя "шаблон" для обратной итерации по закрытым-открытым диапазонам выглядит следующим образом

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

Ответ 4

Пользователь rend() / rbegin() итераторы:

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

Ответ 5

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;

Альтернативно в С++ 14 просто выполните:

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

В С++ 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;

который, я думаю, довольно хорош.

Ответ 6

Используйте обратные итераторы и цикл от rbegin() до rend()

Ответ 7

Мне нравится обратный итератор в конце ответа Yakk - Adam Nevraumont, но он показался мне сложным, поэтому я написал это:

template <class T>
class backwards {
    T& _obj;
public:
    backwards(T &obj) : _obj(obj) {}
    auto begin() {return _obj.rbegin();}
    auto end() {return _obj.rend();}
};

Я могу взять нормальный итератор, как это:

for (auto &elem : vec) {
    // ... my useful code
}

и измените это на это, чтобы повторить в обратном порядке:

for (auto &elem : backwards(vec)) {
    // ... my useful code
}

Ответ 8

Здесь супер простая реализация, которая позволяет использовать для каждой конструкции и опирается только на С++ 14 стандартную библиотеку:

namespace Details {

    // simple storage of a begin and end iterator
    template<class T>
    struct iterator_range
    {
        T beginning, ending;
        iterator_range(T beginning, T ending) : beginning(beginning), ending(ending) {}

        T begin() const { return beginning; }
        T end() const { return ending; }
    };

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// usage:
//  for (auto e : backwards(collection))
template<class T>
auto backwards(T & collection)
{
    using namespace std;
    return Details::iterator_range(rbegin(collection), rend(collection));
}

Это работает с вещами, которые предоставляют rbegin() и rend(), а также со статическими массивами.

std::vector<int> collection{ 5, 9, 15, 22 };
for (auto e : backwards(collection))
    ;

long values[] = { 3, 6, 9, 12 };
for (auto e : backwards(values))
    ;

Ответ 9

используйте этот код

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

Ответ 10

Поскольку я не хочу вводить инопланетный новый синтаксис Mars, и я просто хочу использовать существующие примитивы, приведенные ниже фрагменты работают:

#include <vector>
#include <iostream>

int main (int argc,char *argv[])
{
    std::vector<int> arr{1,2,3,4,5};
    std::vector<int>::iterator it;

    for (it = arr.begin(); it != arr.end(); it++) {
        std::cout << *it << " ";
    }

    std::cout << "\n************\n";

    for (it = arr.end() - 1; it != arr.begin()-1;it--) {
        std::cout << *it << " ";
    }

    return 0;
}