C++11 : boucle for inversée basée sur l'intervalle.

Question

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

Avec des itérateurs explicites, je convertirais ceci :

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

dans ceci :

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

Je veux convertir ça :

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

à ça :

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

Cela existe-t-il ou dois-je l'écrire moi-même ?

Answer 1

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

Answer 2

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

Answer 3

Est-ce que ça marche pour vous :

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

Answer 4

Je ne connaissais pas la version boost. J'avais déjà écrit un adaptateur qui fonctionne, lorsque je suis tombé sur cette question-réponse. Je faisais des recherches sur Stackoverflow pour voir si je pouvais comprendre pourquoi le compilateur MS n'est pas satisfait à moins que j'utilise des types de retour de fin pour begin() et end(). Voici le code qui fonctionne :

#include <string>
#include <iostream>

template<class Fwd>
struct Reverser {
    const Fwd &fwd;
    Reverser<Fwd>(const Fwd &fwd_): fwd(fwd_) {}
    auto begin() -> decltype(fwd.rbegin()) const { return fwd.rbegin(); } 
    auto end() -> decltype(fwd.rend()) const  { return fwd.rend(); } 
};

template<class Fwd>
Reverser<Fwd> reverse(const Fwd &fwd) { return Reverser<Fwd>(fwd); }

int main() {
    using namespace std;
    string str = ".dlrow olleH";
    for(char c: reverse(str)) cout << c;
    cout << endl;
}

UPDATE : En voici un meilleur.

template<class Fwd>
struct Reverser_generic {
    Fwd &fwd;
    Reverser_generic(Fwd& fwd_): fwd(fwd_) {}
    typedef std::reverse_iterator<typename Fwd::iterator> reverse_iterator;
    reverse_iterator begin() { return reverse_iterator(std::end(fwd)); } 
    reverse_iterator end() { return reverse_iterator(std::begin(fwd)); } 
};

template<class Fwd >
struct Reverser_special{
    Fwd &fwd;
    Reverser_special(Fwd& fwd_): fwd(fwd_) {}
    auto begin() -> decltype(fwd.rbegin()){ return fwd.rbegin(); } 
    auto end() ->decltype(fwd.rbegin())   { return fwd.rend(); } 
};

template<class Fwd>
auto reverse_impl(Fwd& fwd, long) -> decltype( Reverser_generic<Fwd>(fwd)){ 
    return Reverser_generic<Fwd>(fwd);
}

template<class Fwd>
auto reverse_impl(Fwd& fwd, int) 
    -> decltype(fwd.rbegin(), Reverser_special<Fwd>(fwd))
{ 
    return Reverser_special<Fwd>(fwd);
}

template<class Fwd>
auto reverse( Fwd&& fwd) -> decltype(reverse_impl(fwd,int(0))) {
    static_assert(!(is_rvalue_reference<Fwd&&>::value), 
        "Cannot pass rvalue_reference to dj::reverse()");
    return reverse_impl(fwd,int(0));
}

Answer 5

Si vous avez une aversion pour Boost, vous pouvez le faire : https://gist.github.com/allyourcode/5eefdff686c5406220f0

J'aimerais que Iterable soit dans la librairie std.