很抱歉的第二個答案，但我覺得這是值得。
呈現函數make_poly_tuple_iterator()它返回一個迭代器，該迭代器將迭代元組中的元素，並使用std名稱空間中的所有算法。
取消引用迭代器會生成boost :: variant <引用類型...>所以函子必須是boost::static_visitor<>的專業化版本。下面
演示，使用這樣的：
int main()
{
using namespace std;
auto x = make_tuple(tagged_string<tag1>("dont print me"),
1,
2.0,
tagged_string<tag2>("three"),
tagged_string<tag3>("or me"));
// this is the statically typed version
for_each(next(begin(x)),
prev(end(x)),
[](const auto& x) { cout << x << endl; });
// and the polymorphic version
auto first = std::next(make_poly_tuple_iterator(begin(x)));
auto last = std::prev(make_poly_tuple_iterator(end(x)));
// note: std::for_each ;-)
std::for_each(first, last, print_it());
return 0;
}
預計業績：
1
2
three
printing: 1
printing: 2
printing: three
完整代碼：
是的，我知道，有可以做出很多很多的改進。 ...
#include <tuple>
#include <utility>
#include <tuple>
#include <cstddef>
#include <string>
#include <iostream>
#include <boost/variant.hpp>
#include <stdexcept>
#include <exception>
template<class Tuple, size_t I>
struct tuple_iterator
{
constexpr tuple_iterator(Tuple& p) : _p(p) {}
static constexpr auto index() { return I; }
static constexpr auto upper_bound() { return std::tuple_size<Tuple>::value; }
static constexpr auto lower_bound() { return 0; }
template<size_t I2> static constexpr auto ValidIndex = I2 >= lower_bound() && I2 < upper_bound();
template<size_t I2, typename = void>
struct de_ref_type { using type = decltype(std::get<0>(std::declval<Tuple>())); };
template<size_t I2>
struct de_ref_type<I2, std::enable_if_t<ValidIndex<I2>>>
{ using type = decltype(std::get<I2>(std::declval<Tuple>())); };
template<size_t I2> using DerefType = typename de_ref_type<I2>::type;
constexpr auto operator++() const { return make_like_me<I+1>(); }
constexpr auto operator--() const { return make_like_me<I-1>(); }
template<size_t I2, std::enable_if_t<(I2 < lower_bound())>* = nullptr>
constexpr auto make_like_me() const { return tuple_iterator<Tuple, lower_bound()>(_p); }
template<size_t I2, std::enable_if_t<(I2 >= upper_bound())>* = nullptr>
constexpr auto make_like_me() const { return tuple_iterator<Tuple, upper_bound()>(_p); }
template<size_t I2, std::enable_if_t<ValidIndex<I2>>* = nullptr>
constexpr auto make_like_me() const { return tuple_iterator<Tuple, I2>(_p); }
constexpr decltype(auto) deref() const { return _p; }
template<size_t X> bool operator==(const tuple_iterator<Tuple, X>& r) const { return false; }
bool operator==(const tuple_iterator<Tuple, I>& r) const {
return std::addressof(_p) == std::addressof(r._p);
}
template<size_t I2, std::enable_if_t<ValidIndex<I2>>* =nullptr>
DerefType<I2> impl_star() const { return std::get<I2>(_p); }
template<size_t I2, std::enable_if_t<not ValidIndex<I2>>* =nullptr>
DerefType<I2> impl_star() const
{ throw std::logic_error("out of range"); }
decltype(auto) operator*() const {
return impl_star<index()>();
}
Tuple& _p;
};
template<class...Ts>
constexpr auto begin(const std::tuple<Ts...>& t) {
return tuple_iterator<const std::tuple<Ts...>, 0>(t);
}
template<class...Ts>
constexpr auto end(const std::tuple<Ts...>& t) {
return tuple_iterator<const std::tuple<Ts...>, sizeof...(Ts)>(t);
}
template<class Tuple, size_t I>
constexpr auto prev(tuple_iterator<Tuple, I> it) { return --it; }
template<class Tuple, size_t I>
constexpr auto next(tuple_iterator<Tuple, I> it) { return ++it; }
namespace detail
{
template <
std::size_t begin,
typename Tuple,
typename F,
std::size_t... Is
>
void for_each(Tuple&& t, F&& f, std::index_sequence<Is...>)
{
using expand = int[];
static_cast<void>(expand{ 0, (f(std::get<begin + Is>(std::forward<Tuple>(t))), void(), 0)... });
}
}
template<class Tuple, size_t First, size_t Last, class Func>
void for_each(tuple_iterator<Tuple, First> first, tuple_iterator<Tuple, Last> last, Func&& f)
{
constexpr auto dist = Last - First;
constexpr auto base = First;
constexpr auto extent = std::make_index_sequence<dist>();
detail::for_each<base>(first.deref(), std::forward<Func>(f), extent);
}
namespace detail {
template<class Tuple>
struct variant_of_tuple;
template<class...Ts>
struct variant_of_tuple<std::tuple<Ts...>>
{
// todo: some work to remove duplicates
using type = boost::variant<std::add_lvalue_reference_t<Ts>...>;
};
template<class...Ts>
struct variant_of_tuple<const std::tuple<Ts...>>
{
// todo: some work to remove duplicates
using type = boost::variant<std::add_lvalue_reference_t<std::add_const_t<Ts>>...>;
};
}
template<class Tuple>
using ToVariant = typename detail::variant_of_tuple<Tuple>::type;
template<class Tuple>
struct poly_tuple_iterator
{
using tuple_type = Tuple;
using value_type = ToVariant<std::remove_reference_t<tuple_type>>;
using difference_type = std::ptrdiff_t;
using pointer = value_type*;
using reference = value_type&;
using iterator_category = std::random_access_iterator_tag;
struct concept {
virtual ~concept() = default;
virtual const std::type_info& type() const = 0;
virtual const void* address() const = 0;
virtual bool equal(const void* p) const = 0;
virtual std::unique_ptr<concept> clone() const = 0;
virtual std::unique_ptr<concept> next() const = 0;
virtual std::unique_ptr<concept> prev() const = 0;
virtual value_type deref() const = 0;
};
template<size_t I>
struct model : concept {
using my_type = tuple_iterator<tuple_type, I>;
model(my_type iter) : _iter(iter) {}
const std::type_info& type() const override { return typeid(_iter); }
const void* address() const override { return std::addressof(_iter); }
std::unique_ptr<concept> clone() const override { return std::make_unique<model<I>>(_iter); };
std::unique_ptr<concept> next() const override {
auto next_iter = ++_iter;
return std::make_unique<model<next_iter.index()>>(next_iter);
};
std::unique_ptr<concept> prev() const override {
auto next_iter = --_iter;
return std::make_unique<model<next_iter.index()>>(next_iter);
};
value_type deref() const override { return { *_iter }; }
bool equal(const void* p) const override {
return _iter == *reinterpret_cast<const my_type*>(p);
}
my_type _iter;
};
template<size_t I>
poly_tuple_iterator(tuple_iterator<tuple_type, I> iter)
: _impl(std::make_unique<model<I>>(iter))
{}
poly_tuple_iterator(const poly_tuple_iterator& r) : _impl(r._impl->clone()) {};
poly_tuple_iterator(poly_tuple_iterator&& r) : _impl(std::move(r._impl)) {};
poly_tuple_iterator& operator=(const poly_tuple_iterator& r) {
_impl = r._impl->clone();
return *this;
}
poly_tuple_iterator& operator=(poly_tuple_iterator&& r) {
auto tmp = r._impl->clone();
std::swap(tmp, _impl);
return *this;
}
value_type operator*() const { return _impl->deref(); }
poly_tuple_iterator& operator++() { _impl = _impl->next(); return *this; }
poly_tuple_iterator operator++(int) { auto tmp = *this; _impl = _impl->next(); return tmp; }
poly_tuple_iterator& operator--() { _impl = _impl->prev(); return *this; }
poly_tuple_iterator operator--(int) { auto tmp = *this; _impl = _impl->prev(); return tmp; }
poly_tuple_iterator& operator+=(difference_type dist) {
while (dist > 0) {
++(*this);
--dist;
}
while(dist < 0) {
--(*this);
++dist;
}
return *this;
}
bool operator==(const poly_tuple_iterator& r) const {
return _impl->type() == r._impl->type()
and _impl->equal(r._impl->address());
}
bool operator!=(const poly_tuple_iterator& r) const {
return not (*this == r);
}
private:
std::unique_ptr<concept> _impl;
};
template<class Tuple, size_t I>
auto make_poly_tuple_iterator(tuple_iterator<Tuple, I> iter) {
return poly_tuple_iterator<Tuple>(iter);
}
struct print_it : boost::static_visitor<void>
{
template<class T>
void operator()(const T& t) const {
std::cout << "printing: " << t << std::endl;
}
template<class...Ts>
void operator()(const boost::variant<Ts...>& v) const {
boost::apply_visitor(*this, v);
}
};
// to differentiate string types for this demo
template<class tag>
struct tagged_string : std::string
{
using std::string::string;
};
struct tag1 {};
struct tag2 {};
struct tag3 {};
int main()
{
using namespace std;
auto x = make_tuple(tagged_string<tag1>("dont print me"),
1,
2.0,
tagged_string<tag2>("three"),
tagged_string<tag3>("or me"));
for_each(next(begin(x)), prev(end(x)), [](const auto& x) { cout << x << endl; });
auto first = std::next(make_poly_tuple_iterator(begin(x)));
auto last = std::prev(make_poly_tuple_iterator(end(x)));
std::for_each(first, last, print_it());
return 0;
}
你可能應該能夠用'index_sequence'完成這項工作。如果你很幸運並且你的實現有非遞歸的內部'index_sequence'，你將會避免遞歸。 – SergeyA
每個迭代器'值'都需要它自己的類型，因爲std :: get <>的模板參數必須是一個constexpr。我認爲遞歸是不可避免的 –
@SergeyA我實際上花了一些時間看'integer_sequence's，但我不能確定如何修改它們的開始和結束值，所以我不能有效地做一個範圍。如果在我的研究中有一些我錯過了，請賜教！ –