Vòng lặp dựa trên phạm vi đảo ngược C ++ 11

Có một bộ chuyển đổi container nào sẽ đảo ngược hướng của các trình vòng lặp để tôi có thể lặp qua một container ngược lại với vòng lặp for-loop dựa trên phạm vi không?

Với các trình vòng lặp rõ ràng tôi sẽ chuyển đổi điều này:

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

vào đây:

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

Tôi muốn chuyển đổi cái này:

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

đến đây:

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

Có một điều như vậy hoặc tôi phải tự viết nó?

Trên thực tế Boost có bộ chuyển đổi như vậy : 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';
}

Trên thực tế, trong C ++ 14 nó có thể được thực hiện với rất ít dòng mã.

Đây là một ý tưởng rất giống với giải pháp của @ Paul. Do những thứ còn thiếu từ C ++ 11, giải pháp đó hơi phồng lên một cách không cần thiết (cộng với việc xác định trong mùi std). Nhờ C ++ 14, chúng tôi có thể làm cho nó dễ đọc hơn rất nhiều.

Quan sát chính là các vòng lặp dựa trên phạm vi hoạt động bằng cách dựa vào begin()và end()để có được các vòng lặp của phạm vi. Nhờ có ADL , người ta thậm chí không cần xác định tùy chỉnh của họ begin()và end()trong không gian tên std ::.

Đây là một giải pháp mẫu rất đơn giản:

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

Điều này hoạt động như một nét duyên dáng, ví dụ:

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

in như mong đợi

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

LƯU Ý std::rbegin() , std::rend()và std::make_reverse_iterator()chưa được triển khai trong GCC-4.9. Tôi viết các ví dụ này theo tiêu chuẩn, nhưng chúng sẽ không biên dịch trong g ++ ổn định. Tuy nhiên, việc thêm sơ khai tạm thời cho ba chức năng này là rất dễ dàng. Đây là một triển khai mẫu, chắc chắn không hoàn thành nhưng hoạt động đủ tốt cho hầu hết các trường hợp:

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

Điều này sẽ hoạt động trong C ++ 11 mà không cần tăng:

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

Công việc này là dành cho bạn:

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

ví dụ:

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

Nếu bạn có thể sử dụng phạm vi v3 , bạn có thể sử dụng bộ điều hợp phạm vi đảo ngược ranges::view::reversecho phép bạn xem container ngược lại.

Một ví dụ làm việc tối thiểu:

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

Xem DEMO 1 .

Lưu ý: Theo Eric Niebler , tính năng này sẽ có trong C ++ 20 . Điều này có thể được sử dụng với <experimental/ranges/range>tiêu đề. Sau đó, fortuyên bố sẽ như thế này:

for (auto const& e : view::reverse(intVec)) {
       std::cout << e << " ";   
}

Xem DEMO 2

Nếu không sử dụng C ++ 14, thì tôi tìm bên dưới giải pháp đơn giản nhất.

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

Bản demo .
Nó không hoạt động đối với các container / kiểu dữ liệu (như mảng), không có begin/rbegin, end/rendchức năng.

Bạn chỉ có thể sử dụng BOOST_REVERSE_FOREACHmà lặp đi lặp lại. Ví dụ: mã

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

tạo đầu ra sau:

4

3

2

1

0