允许访问封装容器

Question

class X {
  public:
    typedef std::list<int> Container;

    // (1)
    const Container& GetElements() const;

    // (2)
    Container::iterator ElementBegin();
    Container::iterator ElementEnd();

    // (3)
    CustomIterator GetElementIterator();

  private:
    Container m_container;
};

我正在寻找一种一致且干净的方式来为调用者提供封装容器的迭代器。我想出了上面源代码中标记的三个想法。

1. 提供 size()、begin() 和 end()，所有这些都非常适合读取访问。但是，由于返回的 Container 引用是 const，您将只能使用 const_iterator。返回引用非常量是不好的，因为容器本身可以被修改（例如clear()）。
2. 提供对元素的非常量访问，但是我们通常需要一个自己的size() 方法（如GetElementCount()）。可以使用iterator::distance()，但对于某些容器来说可能效率低下（其中operator++/-- 被反复调用以计算距离）。
3. 提供带有 next() 等方法的自定义迭代器。仍然需要自己的 size() 方法。

我敢打赌有更好的解决方案，所以如果你知道的话，我会很高兴看到它们。

Answer 1

混合使用 (2) 和 (3) 可能就是我要做的：

class X {
  public :
    typedef std::list<int> ElementContainer;
    typedef ElementContainer::size_type ElementSizeType;
    typedef ElementContainer::iterator ElementIterator;
    typedef ElementContainer::const_iterator ConstElementIterator;

    ElementIterator elementBegin() { return m_container.begin(); }
    ElementIterator elementEnd() { return m_container.end(); }

    ConstElementIterator elementBegin() const { return m_container.begin(); }
    ConstElementIterator elementEnd() const { return m_container.end(); }

    ElementSizeType elementSize() const { return m_container.size(); }

  private :
    ElementContainer m_container;
};

它仍然有编写自定义迭代器的空间（通过更改typedefs），但只要容器提供的那些没问题，它们就可以使用。

Answer 2

我会改用这些名称：iterator、const_iterator、begin、end、cbegin、cend 和 size()：

class X 
{
  public :

    typedef std::list<int>::iterator iterator;
    typedef std::list<int>::const_iterator const_iterator ;

    iterator begin() { return m_container.begin(); }
    iterator end() { return m_container.end(); }

    const_iterator cbegin() const { return m_container.begin(); }
    const_iterator cend() const { return m_container.end(); }

    size_t size() const { return m_container.size(); }

  private :
    std::list<int> m_container;
};

如果你可以使用C++0x，那么使用m_container.cbegin()和m_container.cend()作为：

const_iterator cbegin() const { return m_container.cbegin(); }
const_iterator cend() const { return m_container.cend(); }

Answer 3

我想不出更清洁的方法；您可以考虑使用轻量级 (4) 解决方案提供访问权限

const Container& container() const { return m_container; }

我更喜欢 (3)，因为容器类型已完全封装，即您的类型不一定需要包含，并且您可以更改容器类型而无需重新编译依赖模块。

Answer 4

当然，最简单的是这个：

class X {
  public:
    typedef std::list<int> Container;

    Container m_container;
};

但这会让你的 class X 过时。

除此之外，如果你真的喜欢你的课程，那么添加下一个方法：

Container::const_iterator ElementBegin() const;
Container::const_iterator ElementEnd() const;
int size() const;

Answer 5

2 和 3 确实不是不同的选项。但是，所写的 3 几乎没用。没有 STL 算法将使用CustomIterator::next。为了 STL 兼容性，你会写：

// mix of 2 and 3
CustomIterator begin();
CustomIterator end();

并给CustomIterator标准operator++和operator*

Answer 6

如果你可以使用 Boost，有一个库适合你：http://www.boost.org/doc/libs/1_47_0/libs/iterator/doc/index.html 具体看iterator_facade和iterator_adapter

这里是一个示例 - 它提供了一个 std::vector 持有者，以及与 STL 兼容的迭代器。您可以通过添加其他方法来扩展它，例如 operator[]、size()、push_back() 等。

模板 类 VectorHolder { 民众： typedef T value_type;

公开： 矢量持有人（） : m_values() { }

公开： typedef typename std::vector::iterator vector_iterator; typedef typename std::vector::const_iterator vector_const_iterator;

class iterator : public boost::iterator_adaptor<iterator, vector_iterator>
{
public:
    iterator()
        : iterator::iterator_adaptor_()
    {
    }

    iterator(const vector_iterator& it)
        : iterator::iterator_adaptor_(it)
    {
    }

private:
    friend class boost::iterator_core_access;
};

class const_iterator : public boost::iterator_adaptor<const_iterator, vector_const_iterator>
{
public:
    const_iterator()
        : const_iterator::iterator_adaptor_()
    {
    }

    const_iterator(const vector_const_iterator& it)
        : const_iterator::iterator_adaptor_(it)
    {
    }

    const_iterator(const iterator& it)
        : const_iterator::iterator_adaptor_(it.base())
    {
    }
private:
    friend class boost::iterator_core_access;
};


iterator begin()
{
    return iterator(m_values.begin());
}

iterator end()
{
    return iterator(m_values.end());
}

const_iterator begin() const
{
    return const_iterator(m_values.begin());
}

const_iterator end() const
{
    return const_iterator(m_values.end());
}protected:
std::vector<T> m_values;};