c++ 11反向基于范围for循环

Is there a container adapter that would reverse the direction of iterators so I can iterate over a container in reverse with range-based for-loop?

是否有一个容器适配器可以逆转迭代器的方向，以便我可以使用基于范围的for循环在容器上进行反向迭代?

With explicit iterators I would convert this:

通过显式迭代器，我可以将其转换为:

for (auto i = c.begin(); i != c.end(); ++i) { ...

into this:

到这个:

for (auto i = c.rbegin(); i != c.rend(); ++i) { ...

I want to convert this:

我想把它转换成

for (auto& i: c) { ...

to this:

:

for (auto& i: std::magic_reverse_adapter(c)) { ...

Is there such a thing or do I have to write it myself?

有这样的事情吗?还是我必须自己写?

6 个解决方案

#1

Actually Boost does have such adaptor: boost::adaptors::reverse.

实际上Boost确实有这样的适配器:Boost::adaptors::反向。

#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';
}

#2

Actually, in C++14 it can be done with a very few lines of code.

实际上，在c++ 14中，只需要几行代码就可以完成。

This is a very similar in idea to @Paul's solution. Due to things missing from C++11, that solution is a bit unnecessarily bloated (plus defining in std smells). Thanks to C++14 we can make it a lot more readable.

这与@Paul的解决方案非常相似。由于c++ 11缺少一些东西，这个解决方案有点不必要地膨胀(加上在std气味中定义)。感谢c++ 14，我们可以让它更容易读懂。

The key observation is that ranged-based for-loops work by relying on begin() and end() in order to acquire the range's iterators. Thanks to ADL, one doesn't even need to define their custom begin() and end() in the std:: namespace.

关键的观察是，基于范围的for循环通过依赖于begin()和end()来工作，以获取范围的迭代器。多亏了ADL，人们甚至不需要在std::命名空间中定义他们的自定义begin()和end()。

Here is a very simple-sample solution:

这里有一个非常简单的示例解决方案:

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

This works like a charm, for instance:

这就像一种魅力，例如:

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

prints as expected

按预期输出

4,3,2,1,
4,3,2,1,
3,2,1,0,
0,1,2,3,

NOTE std::rbegin(), std::rend(), and std::make_reverse_iterator() are not yet implemented in GCC-4.9. I write these examples according to the standard, but they would not compile in stable g++. Nevertheless, adding temporary stubs for these three functions is very easy. Here is a sample implementation, definitely not complete but works well enough for most cases:

注意std:::rbegin()、std::rend()和std:::make_reverse_iterator()在GCC-4.9中还没有实现。我根据标准写这些例子，但是它们不会编译成稳定的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());
}

UPDATE 22 Oct 2017

2017年10月22日更新

Thanks to estan for pointing this out.

感谢estan指出这一点。

The original answer sample implementation uses using namespace std;, which would cause any file including this implementation (that has to be in header file), to also import the whole std namespace.

原始的answer示例实现使用名称空间std;这将导致包括该实现(必须在头文件中)的任何文件也导入整个std名称空间。

Revised the sample implementation to propose using std::rbegin, std::rend instead.

修改示例实现，建议使用std::rbegin, std::rend。

#3

This should work in C++11 without boost:

这应该在c++ 11中有效，没有boost:

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))
{
    ...
}

#4

Does this work for you:

这对你有用吗:

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

#5

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

eg:

例如:

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

#6

If not using C++14, then I find below the simplest solution.

如果不使用c++ 14，那么我找到下面最简单的解决方案。

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

Demo.
It doesn't work for the containers/data-types (like array), which doesn't have begin/rbegin, end/rend functions.

演示。它不适用于容器/数据类型(如数组)，它没有开始/rbegin、结束/rend函数。