Question

我有一个自定义容器类并定义了迭代器，所以我可以这样做：

for (auto i : c)

但有反向迭代的东西吗？

类似的东西：

for_reverse (auto i : c)

Answer 1

您可以使用boost：

#include <boost/range/adaptor/reversed.hpp>

using namespace boost::adaptors;
for (auto i : c | reversed)
    ...

或者，如果您不喜欢运算符重载：

#include <boost/range/adaptor/reversed.hpp>

using namespace boost::adaptors;
for (auto i : reverse(c))
    ...

您可以使用std::reverse_iterator定义类似的辅助函数，这样您就不依赖于boost：

template<typename It>
class Range
{
    It b, e;
public:
    Range(It b, It e) : b(b), e(e) {}
    It begin() const { return b; }
    It end() const { return e; }
};

template<typename ORange, typename OIt = decltype(std::begin(std::declval<ORange>())), typename It = std::reverse_iterator<OIt>>
Range<It> reverse(ORange && originalRange) {
    return Range<It>(It(std::end(originalRange)), It(std::begin(originalRange)));
}

然后你可以写：

for (auto i : reverse(c))
    ...

Example

Answer 2

一次性的痛苦

namespace details {
    template <class T> struct _reversed { T& t; _reversed(T& _t): t(_t) {} };
}

template <class T> details::_reversed<T> reversed(T& t) { return details::_reversed<T>(t); }
template <class T> details::_reversed<T const> reversed(T const& t) { return details::_reversed<T const>(t); }

namespace std {
    template <class T> auto begin(details::_reversed<T>& r) -> decltype(r.t.rbegin()) { return r.t.rbegin(); }
    template <class T> auto end(details::_reversed<T>& r) -> decltype(r.t.rend()) { return r.t.rend(); }

    template <class T> auto begin(details::_creversed<T> const& cr) -> decltype(cr.t.rbegin()) { return cr.t.rbegin(); }
    template <class T> auto end(details::_creversed<T> const& cr) -> decltype(cr.t.rend()) { return cr.t.rend(); }
}

然后你可以执行以下操作

for (auto x: reversed(c)) ...

for（auto i：c） - 在反向方向上有一个简短的方法吗？

2 个答案: