c++ - 为一组句柄实现迭代器

Question

我正在为包含一组对象的数据库使用笨拙的 C 库接口(interface)。对象有一个类型，可以说类型 A 的对象包含一组 B 对象等等。通过定义如下的句柄访问对象:

typedef struct
{
    int handle;
} AHandleT; 


typedef struct
{
    int handle;
} BHandleT;

要遍历 A 对象的 B 子对象，使用以下函数:

ReturnT getB(AHandleT /*in*/, BHandleT* /*out*/)
ReturnT getBNext(BHandleT /*in*/, BHandleT* /*out*/)

同样迭代一组 B 对象:

ReturnT getC(BHandleT handle/*in*/, CHandleT* subHandle/*out*/)
ReturnT getCNext(CHandleT handle/*in*/, CHandleT* next/*out*/)

为了在 C++ 中使用此接口(interface)，我制作了以下迭代器，非常感谢您就其实现提出的建议。另外，你认为这是一个好方法吗？请记住，我是 C++ 的新手，我将使用 TDD 编写代码。

template<class HandleT>
class HandleIterator 
{
public:
    typedef ReturnT (*GetNext)(HandleT, HandleT*);

    HandleIterator(): m_isLast(true)
    {
    }

    template<class ParentHandleT>
    HandleIterator(const ParentHandleT parentHandle, ReturnT (*getFirstChild)(ParentHandleT, HandleT*), GetNext getNext): m_isLast(false), m_getNext(getNext)
    {
        ReturnT rc = getFirstChild(parentHandle, &m_currentHandle);
        if(rc == NotExisting)
        {
            m_isLast = true;
        }
    }

    void operator++()
    {
        ReturnT rc = m_getNext(m_currentHandle, &m_currentHandle);
        if(rc == NotExisting)
        {
            m_isLast = true;
        }
    }

    void operator++(int)
    {
        ++(*this);
    }

    const HandleT& operator*() const
    {
        return m_currentHandle;
    }

    const HandleT* operator->() const
    {
        return &m_currentHandle;
    }

    friend bool operator==(const HandleIterator& left, const HandleIterator& right)
    {
        return left.m_isLast == right.m_isLast;
    }

    friend bool operator!=(const HandleIterator& left, const HandleIterator& right)
    {
        return !(left == right);
    }

protected:
    HandleT m_currentHandle;
    bool m_isLast;
    GetNext m_getNext;
};

一旦我有了一个句柄，我就可以使用以下形式的函数从 C 接口(interface)获取对象中包含的数据:

ReturnT getAName(AHandleT)
ReturnT getBName(BHandleT)
ReturnT getBOnlyProprty(BHandleT)

但那是下一阶段。

等等

Answer 1

您的实现非常好，尤其是对于初学者。

只是一些评论:

• 在构造函数中，为什么要传递 getFirstChild 而不是直接提供第一个 child ？
• ++ 的规范签名是 T& operator++() 和 T operator++(int)
• == 应该比较m_isLast，否则会造成混淆。你不能也比较 handle 吗？

最后，在实现迭代器时，考虑继承std::iterator。它没有任何虚方法，但提供了通常在迭代器中期望的 typedef 并会提醒您需要选择一个类别:std::forward_iterator_tag 在这里，很有可能。