web-dev-qa-db-ja.com

C ++ 11逆範囲ベースのforループ

範囲ベースのforループを使用してコンテナの逆方向に反復できるように、反復子の方向を逆にするコンテナアダプタはありますか。

明示的なイテレータではこれを変換します。

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

これに：

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

これを変換したいのですが。

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

これに：

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

そのようなことはありますか、それとも自分で書かなければなりませんか。

c++c++11
293
Alex B

実際にBoostはそのようなアダプタを持っています： 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';
}
215
kennytm

実際、C++ 14では、ほんの数行のコードで実行できます。

これは、@ Paulのソリューションと非常によく似た考え方です。 C++ 11に欠けているものが原因で、その解決策は少し不必要に肥大化しています（さらに、標準臭いで定義すること）。 C++ 14のおかげで、もっと読みやすくなりました。

重要なのは、範囲ベースのforループは、範囲の反復子を取得するためにbegin()とend()に依存することによって機能するということです。 ADL のおかげで、std ::名前空間にカスタムのbegin()とend()を定義する必要すらありません。

これは非常に単純なサンプルソリューションです。

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

これは魅力のように働きます、例えば：

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

期待通りに印刷

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

NOTEstd::rbegin()、std::rend()、およびstd::make_reverse_iterator()はGCC-4.9ではまだ実装されていません。これらの例は標準に従って書いていますが、安定したg ++ではコンパイルできません。それにもかかわらず、これら3つの関数に一時的なスタブを追加するのはとても簡単です。これは実装例です。は完全には完成していませんが、ほとんどの場合は十分に機能します。

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

更新2017年10月22日

これを指摘してくれた estan に感謝します。

オリジナルのanswerサンプル実装ではusing namespace std;を使用しています。これにより、この実装を含むすべてのファイル（ヘッダーファイルに含まれている必要があります）は、std名前空間全体もインポートします。

代わりにusing std::rbegin, std::rendを提案するようにサンプル実装を修正しました。

75
Prikso NAI

これは、C++ 11ではサポートなしで動作するはずです。

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))
{
    ...
}
22
Paul Fultz II

これはあなたのために働きますか？

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

例えば：

    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
Khan Lau

range v を使うことができれば、逆の範囲のアダプタranges::view::reverseを使うことができます。

最小限の実用的な例：

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

デモ1 を参照してください。

注：Eric Niebler によると、この機能はC++で利用可能になります。 20これは<experimental/ranges/range>ヘッダと共に使用できます。 forステートメントは次のようになります。

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

デモ2を参照してください。

3
P.W

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

デモ 。
begin/rbegin, end/rend関数を持たないコンテナ/データ型（配列のような）では動作しません。

2
iammilind

逆方向に繰り返すBOOST_REVERSE_FOREACHを使うことができます。例えば、

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

以下の出力を生成します。

4

3

2

1

0
0
Catriel