你想要的可以用Boost.Variant来实现。
这个想法是定义一种新类型的迭代器，它存储一个包含正向或反向迭代器的变体（把它想象成类固醇上的 C 联合）：
template<class InputRange>
struct any_dir_iterator
: std::iterator_traits<typename boost::range_iterator<InputRange>::type> {
typedef typename boost::range_iterator<InputRange>::type forward_iterator;
typedef typename
boost::range_reverse_iterator<InputRange>::type reverse_iterator;
typedef boost::variant<forward_iterator, reverse_iterator> iterator_type;
iterator_type current_it, end_it;
any_dir_iterator(InputRange & input_range,
bool fwd = true,
bool end = false)
{
end_it = fwd ? iterator_type(boost::end(input_range))
: iterator_type(boost::rend(input_range));
if(end)
current_it = end_it;
else
current_it = fwd ? iterator_type(boost::begin(input_range))
: iterator_type(boost::rbegin(input_range));
}
reference operator*() const {
return boost::apply_visitor(dereference_visitor<any_dir_iterator>(),
current_it);
}
any_dir_iterator & operator++() {
boost::apply_visitor(increment_visitor<any_dir_iterator>(),
current_it);
return *this;
}
bool operator==(any_dir_iterator const & rhs) {
return boost::apply_visitor(equals_visitor<any_dir_iterator>(),
current_it, rhs.current_it);
}
};
这类似于Adobe's any iterator，但不太通用，这意味着与普通迭代器相比，它几乎没有性能开销。
正如您在上面的代码中看到的，所有的逻辑都委托给静态访问者，我们定义如下：
template<class AnyDirIterator>
struct dereference_visitor
: boost::static_visitor<typename AnyDirIterator::iterator_type> {
typedef typename AnyDirIterator::reference result_type;
template<class FwdOrRevIterator>
result_type operator()(FwdOrRevIterator const & it) const {
return *it;
}
};
template<class AnyDirIterator>
struct increment_visitor
: boost::static_visitor<typename AnyDirIterator::iterator_type> {
typedef void result_type;
template<class FwdOrRevIterator>
result_type operator()(FwdOrRevIterator & it) const {
++it;
}
};
template<class AnyDirIterator>
struct equals_visitor
: boost::static_visitor<typename AnyDirIterator::iterator_type>
{
typedef bool result_type;
template <typename FwdOrRevIterator>
bool operator()(FwdOrRevIterator const & lhs,
FwdOrRevIterator const & rhs) const {
return lhs == rhs;
}
template <typename T, typename U>
bool operator()( const T &, const U & ) const {
return false; // comparing fwd to rev or vice-versa
}
};
那是棘手的部分。但是我们仍然需要让它更方便使用，为此我们定义了一个辅助函数，它依赖于Boost.Range 库提供的功能：
template<class InputRange>
boost::iterator_range<any_dir_iterator<InputRange> >
make_any_dir_range(InputRange & range, bool forward=true) {
typedef any_dir_iterator<InputRange> iterator;
return boost::make_iterator_range(iterator(range, forward),
iterator(range, forward, true));
}
仅此而已。现在你可以写了：
int main() {
int items[] = { 1, 2 };
typedef std::vector<int> container_type;
container_type container(items, items + sizeof(items)/sizeof(items[0]));
BOOST_FOREACH(int i, make_any_dir_range(container, true))
std::cout << i << " ";
std::cout << "\n";
BOOST_FOREACH(int i, make_any_dir_range(container, false))
std::cout << i << " ";
return 0;
}
哪些打印：
1 2
2 1
这也适用于 const 容器，尽管我没有在 main 函数中展示这种可能性。
使用 Boost.Range 带来的另一个好处是它适用于开箱即用的数组。所以你可以这样做：
int items[] = { 1, 2 };
BOOST_FOREACH(int i, make_any_dir_range(items, true)) // Prints "1 2"
std::cout << i << " ";
这个答案太简短了，我留下了一些未实现的东西（但它们都是样板，不需要新访问者）：
这里是all the code in Codepad。由于“将警告视为错误”政策，键盘不会吞下它，但 VS2008 和 GCC 4.4 都可以在我的本地机器上编译它。
更新
我做了一些测试，显然boost::variant 确实引入了一些运行时开销：一个基于BOOST_FOREACH 的循环，如main 函数中的循环，比使用普通迭代器的等效版本。检查这是否比 Adobe 的 any_iterator 引入的开销最好还是最差会很有趣。