是否可以将矢量从末尾迭代到开头？
for (vector<my_class>::iterator i = my_vector.end();
i != my_vector.begin(); /* ?! */ ) {
}
或者只有这样的事情才有可能：
for (int i = my_vector.size() - 1; i >= 0; --i) {
}
答案 0 :(得分：114)
嗯，最好的方法是：
for (vector<my_class>::reverse_iterator i = my_vector.rbegin();
i != my_vector.rend(); ++i ) {
}
rbegin（）/ rend（）特别为此目的而设计。 （是的，递增reverse_interator会将其向后移动）
现在，从理论上讲，你的方法（使用begin / end＆amp; --i）会起作用，vector的迭代器是双向的，但是请记住，end（）不是最后一个元素 - 它是最后一个元素元素，所以你必须先减少，当你到达begin（）时你就完成了 - 但是你仍然需要进行处理。
vector<my_class>::iterator i = my_vector.end();
while (i != my_vector.begin())
{
--i;
/*do stuff */ )
}
更新：我显然过于积极地将for（）循环重写为while循环。 （重要的部分是--i在开头。）
答案 1 :(得分：34)
如果你有C ++ 11，你可以使用auto。
for (auto it = my_vector.rbegin(); it != my_vector.rend(); ++it)
{
}
答案 2 :(得分：20)
通过闭合开放范围反向迭代的成熟“模式”如下所示
// 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
}
答案 3 :(得分：9)
用户rend() / rbegin()迭代器：
for (vector<myclass>::reverse_iterator it = myvector.rbegin(); it != myvector.rend(); it++)
答案 4 :(得分：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;
或者在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;
我认为非常漂亮。
答案 5 :(得分：5)
从c ++ 20开始，您可以使用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月），没有主要的编译器实现ranges库，但是您可以诉诸Eric Niebler's 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;
}
答案 6 :(得分：4)
使用反向迭代器并从rbegin()循环到rend()
答案 7 :(得分：1)
如果可以使用Boost库，则Boost.Range可以通过以下方式提供reverse range adapter：
#include <boost/range/adaptor/reversed.hpp>
然后，结合C++11's range-for loop，您可以编写以下内容：
for (auto& elem: boost::adaptors::reverse(my_vector)) {
// ...
}
由于此代码比使用迭代器对的代码简短，因此，由于要注意的细节较少，因此可读性更强，更不容易出错。
答案 8 :(得分：0)
我喜欢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
}
答案 9 :(得分：0)
这是一个超简单的实现，允许对每个结构使用，并且仅依赖于C ++ 14 std库：
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))
;
答案 10 :(得分：-1)
使用此代码
//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;
}
答案 11 :(得分：-2)
由于我不想引入外星人火星的新语法，而我只是想在现有的基元上构建，因此以下代码片段似乎有效：
#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;
}