是否存在一种容器适配器，可以反转迭代器的方向，这样我就可以通过range-based for-loop以相反的顺序迭代容器了？
使用显式迭代器，我会将其转换为：
for (auto i = c.begin(); i != c.end(); ++i) { ...
变成这样:
for (auto i = c.rbegin(); i != c.rend(); ++i) { ...
我想将这个转换成：
for (auto& i: c) { ...
变成这个：
for (auto& i: std::magic_reverse_adapter(c)) { ...
有这样的东西吗，或者我必须自己编写？
实际上Boost确实拥有这样的适配器：boost::adaptors::reverse。
#include <list>
#include <iostream>
#include <boost/range/adaptor/reversed.hpp>
int main()
{
std::list<int> x { 2, 3, 5, 7, 11, 13, 17, 19 };
for (auto i : boost::adaptors::reverse(x))
std::cout << i << '\n';
for (auto i : x)
std::cout << i << '\n';
}
实际上，在C++14中可以用非常少的代码完成。
这个想法与@Paul的解决方案非常相似。由于C++11缺少一些东西，那个解决方案有点过度膨胀（而且在std中定义会有味道）。感谢C++14，我们可以使它更加易读。
关键观察是，基于范围的for循环是通过依赖于begin()和end()来获取范围的迭代器来工作的。由于ADL，甚至不需要在std命名空间中定义自定义的begin()和end()。
这里是一个非常简单的示例解决方案:
// -------------------------------------------------------------------
// --- Reversed iterable
template <typename T>
struct reversion_wrapper { T& iterable; };
template <typename T>
auto begin (reversion_wrapper<T> w) { return std::rbegin(w.iterable); }
template <typename T>
auto end (reversion_wrapper<T> w) { return std::rend(w.iterable); }
template <typename T>
reversion_wrapper<T> reverse (T&& iterable) { return { iterable }; }
这真是太棒了，例如：
template <typename T>
void print_iterable (std::ostream& out, const T& iterable)
{
for (auto&& element: iterable)
out << element << ',';
out << '\n';
}
int main (int, char**)
{
using namespace std;
// on prvalues
print_iterable(cout, reverse(initializer_list<int> { 1, 2, 3, 4, }));
// on const lvalue references
const list<int> ints_list { 1, 2, 3, 4, };
for (auto&& el: reverse(ints_list))
cout << el << ',';
cout << '\n';
// on mutable lvalue references
vector<int> ints_vec { 0, 0, 0, 0, };
size_t i = 0;
for (int& el: reverse(ints_vec))
el += i++;
print_iterable(cout, ints_vec);
print_iterable(cout, reverse(ints_vec));
return 0;
}
正如预期的那样打印
4,3,2,1,
4,3,2,1,
3,2,1,0,
0,1,2,3,
注意：GCC-4.9版本中还未实现std::rbegin()、std::rend()和std::make_reverse_iterator()。我根据标准编写这些示例，但它们不能在稳定版本的g++中编译。不过，为这三个函数添加临时存根非常容易。下面是一个示例实现，虽然不完整，但对于大多数情况已经足够：
// --------------------------------------------------
template <typename I>
reverse_iterator<I> make_reverse_iterator (I i)
{
return std::reverse_iterator<I> { i };
}
// --------------------------------------------------
template <typename T>
auto rbegin (T& iterable)
{
return make_reverse_iterator(iterable.end());
}
template <typename T>
auto rend (T& iterable)
{
return make_reverse_iterator(iterable.begin());
}
// const container variants
template <typename T>
auto rbegin (const T& iterable)
{
return make_reverse_iterator(iterable.end());
}
template <typename T>
auto rend (const T& iterable)
{
return make_reverse_iterator(iterable.begin());
}
reverse实现中忘记了使用forward<T>。 - SnakEusing namespace std，这不是一个好主意。或者我漏掉了什么？ - estan我从cppreference获取了这个示例。 它适用于：
GCC 10.1+，带有标志-std=c++20。
#include <ranges>
#include <iostream>
int main()
{
static constexpr auto il = {3, 1, 4, 1, 5, 9};
std::ranges::reverse_view rv {il};
for (int i : rv)
std::cout << i << ' ';
std::cout << '\n';
for(int i : il | std::views::reverse)
std::cout << i << ' ';
}
如果您可以使用range v3，那么您可以使用反向范围适配器ranges::view::reverse，它允许您以反向方式查看容器。
一个最小的工作示例：
#include <iostream>
#include <vector>
#include <range/v3/view.hpp>
int main()
{
std::vector<int> intVec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
for (auto const& e : ranges::view::reverse(intVec)) {
std::cout << e << " ";
}
std::cout << std::endl;
for (auto const& e : intVec) {
std::cout << e << " ";
}
std::cout << std::endl;
}
请查看DEMO 1。
注意：根据Eric Niebler的说法，此功能将在C++20中提供。 这可以与<experimental/ranges/range>头文件一起使用。 然后，for语句将如下所示:
for (auto const& e : view::reverse(intVec)) {
std::cout << e << " ";
}
请参见DEMO 2
ranges::view 命名空间已更名为 ranges::views。因此，请使用 ranges::views::reverse。 - nac001这应该在不使用boost的情况下在C++11中工作：
namespace std {
template<class T>
T begin(std::pair<T, T> p)
{
return p.first;
}
template<class T>
T end(std::pair<T, T> p)
{
return p.second;
}
}
template<class Iterator>
std::reverse_iterator<Iterator> make_reverse_iterator(Iterator it)
{
return std::reverse_iterator<Iterator>(it);
}
template<class Range>
std::pair<std::reverse_iterator<decltype(begin(std::declval<Range>()))>, std::reverse_iterator<decltype(begin(std::declval<Range>()))>> make_reverse_range(Range&& r)
{
return std::make_pair(make_reverse_iterator(begin(r)), make_reverse_iterator(end(r)));
}
for(auto x: make_reverse_range(r))
{
...
}
std命名空间中重载函数会产生未定义的行为，根据17.6.4.2.1。 - Caseymake_reverse_iterator不在std命名空间中，因此它不会与C++14版本发生冲突。 - Paul Fultz II抱歉，除了C++20之外的当前C++版本中，所有这些解决方案似乎都不如使用基于索引的for循环好。这里没有什么是只有“几行代码”的。因此，是的：通过一个简单的int循环来迭代。这是最佳解决方案。
rbegin()/rend()。 - Alexis Wilke这个对你起作用吗：
#include <iostream>
#include <list>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/iterator_range.hpp>
int main(int argc, char* argv[]){
typedef std::list<int> Nums;
typedef Nums::iterator NumIt;
typedef boost::range_reverse_iterator<Nums>::type RevNumIt;
typedef boost::iterator_range<NumIt> irange_1;
typedef boost::iterator_range<RevNumIt> irange_2;
Nums n = {1, 2, 3, 4, 5, 6, 7, 8};
irange_1 r1 = boost::make_iterator_range( boost::begin(n), boost::end(n) );
irange_2 r2 = boost::make_iterator_range( boost::end(n), boost::begin(n) );
// prints: 1 2 3 4 5 6 7 8
for(auto e : r1)
std::cout << e << ' ';
std::cout << std::endl;
// prints: 8 7 6 5 4 3 2 1
for(auto e : r2)
std::cout << e << ' ';
std::cout << std::endl;
return 0;
}
template <typename C>
struct reverse_wrapper {
C & c_;
reverse_wrapper(C & c) : c_(c) {}
typename C::reverse_iterator begin() {return c_.rbegin();}
typename C::reverse_iterator end() {return c_.rend(); }
};
template <typename C, size_t N>
struct reverse_wrapper< C[N] >{
C (&c_)[N];
reverse_wrapper( C(&c)[N] ) : c_(c) {}
typename std::reverse_iterator<const C *> begin() { return std::rbegin(c_); }
typename std::reverse_iterator<const C *> end() { return std::rend(c_); }
};
template <typename C>
reverse_wrapper<C> r_wrap(C & c) {
return reverse_wrapper<C>(c);
}
例如：
int main(int argc, const char * argv[]) {
std::vector<int> arr{1, 2, 3, 4, 5};
int arr1[] = {1, 2, 3, 4, 5};
for (auto i : r_wrap(arr)) {
printf("%d ", i);
}
printf("\n");
for (auto i : r_wrap(arr1)) {
printf("%d ", i);
}
printf("\n");
return 0;
}
BOOST_REVERSE_FOREACH进行反向迭代。例如，代码如下：#include <iostream>
#include <boost\foreach.hpp>
int main()
{
int integers[] = { 0, 1, 2, 3, 4 };
BOOST_REVERSE_FOREACH(auto i, integers)
{
std::cout << i << std::endl;
}
return 0;
}
4
3
2
1
0
<boost/foreach.hpp> 吗？ - undefined#define METHOD(NAME, ...) auto NAME __VA_ARGS__ -> decltype(m_T.r##NAME) { return m_T.r##NAME; }
template<typename T>
struct Reverse
{
T& m_T;
METHOD(begin());
METHOD(end());
METHOD(begin(), const);
METHOD(end(), const);
};
#undef METHOD
template<typename T>
Reverse<T> MakeReverse (T& t) { return Reverse<T>{t}; }
演示。
对于没有 begin/rbegin, end/rend 函数的容器/数据类型（例如数组），此方法不起作用。
begin到end迭代或处理流迭代器等情况时更好且更简洁。虽然范围算法很棒，但它们实际上只是迭代器算法的语法糖（除了可能有惰性评估的可能性）。 - Nicol Bolasconst版本等），但它已经能够正常工作。以下是示例代码：vector<int> v {1, 2, 3}; reverse_adapter<decltype(v)> ra; for (auto& i : ra) cout << i;输出结果为321。 - Seth Carnegietemplate<typename T> reverse_adapter<T> reverse_adapt_container(T &c) {return reverse_adapter<T>(c);}这样你就可以使用for(auto &i: reverse_adapt_container(v)) cout << i;来迭代了。 - Nicol Bolasparallel_for就是这种情况下的更强烈的“我不关心顺序”的条件。当然，它也可以具有基于范围的语法糖 :-) - Steve Jessop