Адаптер итератора C++, который обертывает и скрывает внутренний итератор и преобразует повторяемый тип

Я не вижу причин, по которым вы не можете реализовать это именно так, как вы это изложили ... Я что-то упускаю?

Чтобы уточнить, вам нужно поместить какие-то методы доступа в свой класс контейнера. Они могут быть частными, и вы можете объявить MagicIterator своим другом, если вы считаете, что это лучший способ инкапсулировать его, но я бы раскрыл их напрямую. Эти методы доступа будут использовать обычный итератор STL внутри контейнера и выполнять преобразование в интерфейс IInterface. Таким образом, итерация будет фактически выполняться с помощью методов доступа контейнера, а MagicIterator будет просто своего рода прокси-объектом, чтобы упростить задачу. Чтобы сделать его реентерабельным, вы можете передать MagicIterator какой-то идентификатор для поиска итератора STL внутри контейнера, или вы могли бы передать его в итератор STL как void *.

Это действительно зависит от Container, потому что возвращаемые значения c.Begin() и c.End() определяются реализацией.

Если Container известен список возможных MagicIterator, можно использовать класс оболочки.

template<typename T>
class MagicIterator
{
    public:
        MagicIterator(std::vector<T>::const_iterator i)
        {
            vector_const_iterator = i;
        }

        // Reimplement similarly for more types.
        MagicIterator(std::vector<T>::iterator i);
        MagicIterator(std::list<T>::const_iterator i);
        MagicIterator(std::list<T>::iterator i);

        // Reimplement operators here...

    private:
        std::vector<T>::const_iterator vector_const_iterator;
        std::vector<T>::iterator       vector_iterator;
        std::list<T>::const_iterator   list_const_iterator;
        std::list<T>::iterator         list_iterator;
};

Способ легкий заключался бы в использовании шаблона, который принимает тип Container:

// C++0x
template<typename T>
class Iterator :
    public T::iterator
{
    using T::iterator::iterator;
};

for(Iterator<Container> i = c.begin(); i != c.end(); ++i)
{
    // ...
}

Больше информации здесь.

Создайте абстрактный класс IteratorImplementation:

template<typename T>
class IteratorImplementation
{
    public:
        virtual ~IteratorImplementation() = 0;

        virtual T &operator*() = 0;
        virtual const T &operator*() const = 0;

        virtual Iterator<T> &operator++() = 0;
        virtual Iterator<T> &operator--() = 0;
};

И класс Iterator, чтобы обернуть его:

template<typename T>
class Iterator
{
    public:
        Iterator(IteratorImplementation<T> * = 0);
        ~Iterator();

        T &operator*();
        const T &operator*() const;

        Iterator<T> &operator++();
        Iterator<T> &operator--();

    private:
        IteratorImplementation<T> *i;
}

Iterator::Iterator(IteratorImplementation<T> *impl) :
    i(impl)
{
}

Iterator::~Iterator()
{
    delete i;
}

T &Iterator::operator*()
{
    if (!impl)
    {
        // Throw exception if you please.
        return;
    }

    return (*impl)();
}

// etc.

(Вы можете сделать IteratorImplementation классом "внутри" Iterator, чтобы все было в порядке.)

В вашем классе Container верните экземпляр Iterator с настраиваемым подклассом IteratorImplementation в ctor:

class ObjectContainer
{
    public:
        void insert(Object *o);
        // ...

        Iterator<Object *> begin();
        Iterator<Object *> end();

    private:
        class CustomIteratorImplementation :
            public IteratorImplementation<Object *>
        {
            public:
                // Re-implement stuff here.
        }
};

Iterator<Object *> ObjectContainer::begin()
{
    CustomIteratorImplementation *impl = new CustomIteratorImplementation();  // Wish we had C++0x's "var" here.  ;P

    return Iterator<Object *>(impl);
}

Звучит не слишком сложно. Вы можете определить итератор снаружи. Вы также можете использовать typedefs. Думаю, что-то вроде этого подошло бы. Обратите внимание, что было бы намного чище, если бы этот MagicIterator был бы нет свободным шаблоном, но, возможно, членом Item, тип которого определен в контейнере. На данный момент в нем есть циклическая ссылка, из-за которой необходимо написать некрасивый код обходного пути.

namespace detail {
    template<typename T, typename U>
    struct constify;

    template<typename T, typename U>
    struct constify<T*, U*> {
        typedef T * type;
    };

    template<typename T, typename U>
    struct constify<T*, U const*> {
        typedef T const * type;
    };
}

template<typename DstType, 
         typename Container,
         typename InputIterator>
struct MagicIterator;

class Container
{
private:
    struct Item
    {
        Object* pObject;
    };

    std::list<Item> m_items;

public:

    // required by every Container for the iterator
    typedef std::list<Item> iterator;
    typedef std::list<Item> const_iterator;

    // convenience declarations
    typedef MagicIterator< IInterface*, Container, iterator > 
        item_iterator;
    typedef MagicIterator< IInterface*, Container, const_iterator > 
        const_item_iterator;

    item_iterator Begin();
    item_iterator End();
};

template<typename DstType, 
         typename Container = Container,
         typename InputIterator = typename Container::iterator>
struct MagicIterator : 
    // pick either const T or T, depending on whether it's a const_iterator.
    std::iterator<std::input_iterator_tag, 
                  typename detail::constify<
                           DstType, 
                           typename InputIterator::value_type*>::type> {
    typedef std::iterator<std::input_iterator_tag, 
                 typename detail::constify<
                          DstType, 
                          typename InputIterator::value_type*>::type> base;
    MagicIterator():wrapped() { }
    explicit MagicIterator(InputIterator const& it):wrapped(it) { }
    MagicIterator(MagicIterator const& that):wrapped(that.wrapped) { }

    typename base::value_type operator*() {
        return (*wrapped).pObject->GetInterface();
    }

    MagicIterator& operator++() {
        ++wrapped;
        return *this;
    }

    MagicIterator operator++(int) {
        MagicIterator it(*this);
        wrapped++;
        return it;
    }

    bool operator==(MagicIterator const& it) const {
        return it.wrapped == wrapped;
    }

    bool operator!=(MagicIterator const& it) const {
        return !(*this == it);
    }

    InputIterator wrapped;
};

// now that the iterator adepter is defined, we can define Begin and End
inline Container::item_iterator Container::Begin() {
    return item_iterator(m_items.begin());
}

inline Container::item_iterator Container::End() {
    return item_iterator(m_items.end());
}

А теперь начните его использовать:

for(MagicIterator<IInterface*> it = c.Begin(); it != c.End(); ++it) {
    // ...
}

Вы также можете использовать миксин итератора, предоставляемый boost, который работает как входная версия boost :: function_output_iterator. Он вызывает ваш итератор operator(), который затем возвращает соответствующее значение, в принципе делая то, что мы делаем выше в нашем operator*. Вы найдете его в random/detail/iterator_mixin.hpp. Это, вероятно, приведет к меньшему количеству кода. Но для этого также нужно напрячь шею, чтобы обеспечить дружелюбие, потому что Item является частным, а итератор не определен внутри Item. В любом случае, удачи :)

Я думаю, у вас есть две отдельные проблемы:

Сначала создайте итератор, который будет возвращать IInterface* из вашего list<Container::Item>. Это легко сделать с boost::iterator_adaptor:

class cont_iter
  : public boost::iterator_adaptor<
        cont_iter                       // Derived
      , std::list<Container::Item>::iterator // Base
      , IInterface*                     // Value
      , boost::forward_traversal_tag    // CategoryOrTraversal
      , IInterface*                     // Reference :)
    >
{
 public:
    cont_iter()
      : cont_iter::iterator_adaptor_() {}

    explicit cont_iter(const cont_iter::iterator_adaptor_::base_type& p)
      : cont_iter::iterator_adaptor_(p) {}

 private:
    friend class boost::iterator_core_access;
    IInterface* dereference() { return this->base()->pObject->GetInterface(); }
};

Вы должны создать этот тип как внутренний в Container и вернуться из его методов begin() и end().

Во-вторых, вам нужен MagicIterator, полиморфный во время выполнения. Именно это и делает any_iterator. MagicIterator<IInterface*> - это просто any_iterator<IInterface*, boost::forward_traversal_tag, IInterface*>, и ему можно просто назначить cont_iter.

Теперь я нашел решение, которое подходит для моей первоначальной цели. Но мне все равно это не нравится :)

Решение включает в себя шаблон MagicIterator на IInterface *, построенный с использованием как void * для итератора, размера байта указанного итератора, так и таблицы указателей на функции, которые выполняют стандартные функции итерации на указанном void *, такие как приращение, декремент, разыменование и т. д. MagicIterator предполагает, что запоминание данного итератора во внутреннем буфере безопасно, и реализует свои собственные члены, передавая свой собственный буфер как void * предоставленным функциям, как если бы это был исходный итератор.

Затем контейнер должен реализовать функции статической итерации, которые возвращают предоставленный void * в std :: list :: iterator. Container :: begin () и Container :: end () просто создают std :: list :: iterator, передают указатель на него в MagicIterator вместе с таблицей его итерационных функций и возвращают MagicIterator.

Это несколько отвратительно и нарушает мое первоначальное правило относительно «no memcpy ()» и делает предположения о внутреннем устройстве рассматриваемых итераторов. Но он избегает выделения кучи, сохраняет внутренние компоненты Collection (включая Item) закрытыми, делает MagicIterator полностью независимым от рассматриваемой коллекции и IInterface * и теоретически позволяет MagicIterator работать с любой коллекцией (при условии, что ее итераторы могут быть безопасно memcopy () ' г).

Посетитель может быть более простым (и, следовательно, более простым в обслуживании) решением.