Boucle basée sur la plage inverse C ++ 11

Existe-t-il un adaptateur de conteneur qui inverserait la direction des itérateurs afin que je puisse itérer sur un conteneur en sens inverse avec une boucle basée sur une plage?

Avec des itérateurs explicites, je convertirais ceci:

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

en cela:

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

Je veux convertir ceci:

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

pour ça:

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

Existe-t-il une telle chose ou dois-je l'écrire moi-même?

En fait , Boost avoir un tel adaptateur ne: 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';
}

En fait, en C ++ 14, cela peut être fait avec très peu de lignes de code.

C'est une idée très similaire à la solution de @ Paul. En raison de choses manquantes dans C ++ 11, cette solution est un peu gonflée (plus la définition des odeurs std). Grâce à C ++ 14, nous pouvons le rendre beaucoup plus lisible.

L'observation clé est que les boucles for basées sur la plage fonctionnent en s'appuyant sur begin()et end()pour acquérir les itérateurs de la plage. Grâce à ADL , on n'a même pas besoin de définir leur custom begin()et end()dans l'espace de noms std ::.

Voici une solution d'échantillon très simple:

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

Cela fonctionne comme un charme, par exemple:

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

imprime comme prévu

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

NOTE std::rbegin() , std::rend()et std::make_reverse_iterator()ne sont pas encore implémentés dans GCC-4.9. J'écris ces exemples selon la norme, mais ils ne compileraient pas en g ++ stable. Néanmoins, l'ajout de stubs temporaires pour ces trois fonctions est très simple. Voici un exemple d'implémentation, certainement pas complet mais qui fonctionne assez bien dans la plupart des cas:

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

Cela devrait fonctionner en C ++ 11 sans 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))
{
    ...
}

Est-ce que ça marche pour toi:

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

par exemple:

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

Si vous pouvez utiliser la gamme v3 , vous pouvez utiliser l'adaptateur de plage inverse ranges::view::reversequi vous permet de visualiser le conteneur en sens inverse.

Un exemple de travail minimal:

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

Voir DEMO 1 .

Remarque: Selon Eric Niebler , cette fonctionnalité sera disponible en C ++ 20 . Cela peut être utilisé avec l'en- <experimental/ranges/range>tête. Ensuite, la fordéclaration ressemblera à ceci:

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

Voir DEMO 2

Si vous n'utilisez pas C ++ 14, je trouve ci-dessous la solution la plus simple.

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

Démo .
Cela ne fonctionne pas pour les conteneurs / types de données (comme le tableau), qui n'ont pas de begin/rbegin, end/rendfonctions.

Vous pouvez simplement utiliser BOOST_REVERSE_FOREACHce qui se répète en arrière. Par exemple, le code

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

génère la sortie suivante:

4

3

2

1

0