Question

这是一个相当普通的STL容器封装，它允许Cfoo的用户迭代容器而不允许更改内部。

#include <vector>

class Cfoo
{
public:
    class Cbar
    {
        /* contents of Cbar */
    };
    typedef std::vector<Cbar> TbarVector;
    typedef TbarVector::const_iterator const_iterator;     
public:
    const_iterator begin() const { return( barVector_.begin() ); }
    const_iterator end() const { return( barVector_.end() ); }
private:
    TbarVector barVector_;
};

到目前为止，这么好。我们可以像这样迭代容器：

Cfoo myFoo;
for (Cfoo::const_iterator it = myFoo.begin(); it != myFoo.end(); ++it)
{
   it->DoSomething();
}

现在我想用一个嵌套的std :: vector：

替换std :: vector

public:
    typedef std::vector<Cbar> TbarVectorInner;
    typedef std::vector<TbarVectorInner> TbarVectorOuter;

private:
    TbarVectorOuter barContainer_;

但是我希望能够以与以前相同的方式迭代Cbar的所有实例，公开const_iterator，以及begin（）const和end（）const方法。

我不清楚如何做到这一点，虽然我怀疑它涉及编写自定义迭代器。有什么想法吗？

Answer 1

没有一个标准迭代器可以迭代多个容器，所以你的假设是正确的 - 你必须编写一个自定义迭代器。

如果你有一个中间迭代器可以将（begin，end）迭代器对返回到内部容器，那么可以以通用的方式执行此操作。

一些未经测试的代码：

template<typename T, typename OuterIterator, typename InnerIterator>
class Iterator2d : std::Iterator
{
public:
    Iterator2d(OuterIterator begin, OuterIterator end) : m_begin(begin), m_end(end), m_currentOuter(begin)    {
        if (m_currentOuter != m_end)
             m_currentInner = m_begin->first;
        Normalize();
    }
    Iterator2d & operator++()
    {
        if (m_currentOuter != m_end)
        {
            ++m_currentInner;
            Normalize();
        }
        return *this;
    }
    T & operator*()
    {
        return *m_currentInner;
    }
private:
    void Normalize()
    {
        while (m_currentOuter != m_end && m_currentInner == m_currentOuter->second)
        {
            ++m_currentOuter;
            if (m_currentOuter != m_end)
                m_currentInner = m_currentOuter->first;
        }
    }

    OuterIterator m_begin;
    OuterIterator m_end;
    OuterIterator m_currentOuter;
    InnerIterator m_currentInner;
};

这只是一个开始，我可能会回来完成它 - 或者不是，取决于this implementation已经涵盖了相同的基础。

迭代封装的嵌套STL容器

1 个答案: