C++11 Umgekehrte bereichsbasierte for-Schleife

Question

Gibt es einen Container-Adapter, der die Richtung der Iteratoren umkehren würde, so dass ich über einen Container in umgekehrter Richtung mit Bereich-basierte for-Schleife iterieren kann?

Bei expliziten Iteratoren würde ich dies umsetzen:

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

in diese:

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

Ich möchte dies umwandeln:

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

dazu:

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

Gibt es so etwas, oder muss ich es selbst schreiben?

Answer 1

Tatsächlich hat Boost einen solchen Adapter: 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

In C++14 kann dies mit wenigen Zeilen Code erreicht werden.

Die Idee ist der von @Paul sehr ähnlich. Aufgrund von Dingen, die in C++11 fehlen, ist diese Lösung ein wenig unnötig aufgebläht (plus Definition in std smells). Dank C++14 können wir es viel lesbarer machen.

Die wichtigste Beobachtung ist, dass bereichsbasierte for-Schleifen funktionieren, indem sie sich auf begin() y end() um die Iteratoren des Bereichs zu erfassen. Dank ADL muss man noch nicht einmal seine eigene Norm definieren. begin() y end() im std:: Namespace.

Hier ist ein sehr einfaches Lösungsbeispiel:

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

Das funktioniert zum Beispiel sehr gut:

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

druckt wie erwartet

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

ANMERKUNG std::rbegin() , std::rend() y std::make_reverse_iterator() sind im GCC-4.9 noch nicht implementiert. Ich schreibe diese Beispiele nach dem Standard, aber sie würden nicht in stabilem G++ kompilieren. Dennoch ist es sehr einfach, temporäre Stubs für diese drei Funktionen hinzuzufügen. Hier ist eine Beispielimplementierung, definitiv nicht vollständig funktioniert aber in den meisten Fällen gut genug:

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

Answer 3

Dieses Beispiel stammt von cpp-Referenz . Es funktioniert mit:

GCC 10.1+ mit Flagge -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 << ' ';
}

Answer 4

Wenn Sie Folgendes verwenden können Bereich v3 können Sie den Adapter mit umgekehrter Reichweite verwenden ranges::view::reverse die es Ihnen ermöglicht, den Container in umgekehrter Reihenfolge zu betrachten.

Ein minimales Arbeitsbeispiel:

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

Siehe DEMO 1 .

Anmerkung: Gemäß Eric Niebler wird diese Funktion verfügbar sein in C++20 . Dies kann mit dem <experimental/ranges/range> Kopfzeile. Dann wird die for Anweisung wird folgendermaßen aussehen:

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

Siehe DEMO 2

Answer 5

Dies sollte in C++11 ohne Boost funktionieren:

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