一个 C++ 迭代器适配器，它包装和隐藏内部迭代器并转换迭代类型

我现在找到了一个更适合我最初目的的解决方案.不过我还是不喜欢:)

解决方案涉及在 IInterface* 上对 MagicIterator 进行模板化，并使用指向迭代器的 void*、所述迭代器的字节大小以及指向在所述 void* 上执行标准迭代函数(例如增量)的函数的指针表构造，递减，取消引用等.MagicIterator 假设将给定的迭代器 memcpy 到内部缓冲区是安全的，并通过将自己的缓冲区作为 void* 传递给提供的函数来实现其自己的成员，就好像它是原始迭代器一样.

Container 然后必须实现静态迭代函数，将提供的 void* 转换回 std::list::iterator.Container::begin() 和 Container::end() 只需构造一个 std::list::iterator，将指向它的指针连同其迭代函数表一起传递给 MagicIterator，然后返回 MagicIterator.

这有点恶心，打破了我关于no memcpy()"的原始规则，并对所讨论的迭代器的内部进行了假设.但它避免了堆分配，保持 Collection 的内部(包括 Item)私有，使 MagicIterator 完全独立于所讨论的集合和 IInterface*，并且理论上允许 MagicIterators 与任何集合一起工作(只要它的迭代器可以安全地 memcopy()'d).

Having toyed with this I suspect it isn't remotely possible, but I thought I'd ask the experts. I have the following C++ code:

class IInterface
{
    virtual void SomeMethod() = 0;
};

class Object
{
    IInterface* GetInterface() { ... }
};

class Container
{
private:
    struct Item
    {
        Object* pObject;
        [... other members ...]
    };
    std::list<Item> m_items;
};

I want to add these methods to Container:

    MagicIterator<IInterface*> Begin();
    MagicIterator<IInterface*> End();

In order that callers can write:

Container c = [...]
for (MagicIterator<IInterface*> i = c.Begin(); i != c.End(); i++)
{
    IInterface* pItf = *i;
    [...]
}

So essentially I want to provide a class which appears to be iterating over some collection (which the caller of Begin() and End() is not allowed to see) of IInterface pointers, but which is actually iterating over a collection of pointers to other objects (private to the Container class) which can be converted into IInterface pointers.

A few key points:

• MagicIterator is to be defined outside Container.
• Container::Item must remain private.

• MagicIterator has to iterate over IInterface pointers, despite the fact that Container holds a std::list<Container::Item>. Container::Item contains an Object*, and Object can be used to fetch IInterface*.

• MagicIterator has to be reusable with several classes which resemble Container, but might internally have different list implementations holding different objects (std::vector<SomeOtherItem>, mylist<YetAnotherItem>) and with IInterface* obtained in a different manner each time.

• MagicIterator should not contain container-specific code, though it may delegate to classes which do, provided such delegation is not hard coded to to particular containers inside MagicIterator (so is somehow resolved automatically by the compiler, for example).

• The solution must compile under Visual C++ without use of other libraries (such as boost) which would require a license agreement from their authors.

• Also, iteration may not allocate any heap memory (so no new() or malloc() at any stage), and no memcpy().

Thanks for your time, even if you're just reading; this one's really been bugging me!

Update: Whilst I've had some very interesting answers, none have met all the above requirements yet. Notably the tricky areas are i) decoupling MagicIterator from Container somehow (default template arguments don't cut it), and ii) avoiding heap allocation; but I'm really after a solution which covers all of the above bullets.

I've now found a solution which is fitter for my original purpose. I still don't like it though :)

The solution involves MagicIterator being templated on IInterface* and being constructed with both a void* to an iterator, the byte size of said iterator, and a table of pointers to functions which perform standard iteration functions on said void* such as increment, decrement, dereference, etc. MagicIterator assumes that it is safe to memcpy the given iterator into an internal buffer, and implements its own members by passing its own buffer as a void* to the supplied functions as if it were the original iterator.

Container then has to implement static iteration functions which cast back a supplied void* to a std::list::iterator. Container::begin() and Container::end() simply construct a std::list::iterator, pass a pointer to it into a MagicIterator along with a table of its iteration functions, and return the MagicIterator.

It's somewhat disgusting, and breaks my original rule regarding "no memcpy()", and makes assumptions about the internals of the iterators in question. But it avoids heap allocation, keeps Collection's internals (including Item) private, renders MagicIterator entirely independent of the collection in question and of IInterface*, and in theory allows MagicIterators to work with any collection (provided its iterators can be safely memcopy()'d).