公开自定义 STL 样式迭代的首选方法是什么？

Question

（另见Is there a good way not to hand-write all twelve required Container functions for a custom type in C++?）

---

对于一个类如

namespace JDanielSmith {
class C
{
    const size_t _size;
    const std::unique_ptr<int[]> _data;

public:
    C(size_t size) : _size(size), _data(new int[size]) {}

    inline const int* get() const noexcept { return _data.get(); }
    inline int* get() noexcept { return _data.get(); }

    size_t size() const noexcept { return _size; }
};
}

公开迭代的首选方式是什么？我应该写begin()/end()（和cbegin()/cend()）成员函数吗？

const int* cbegin() const {
    return get();
}
const int* cend() const {
    return cbegin() + size();
}

或者这些应该是非成员函数？

const int* cbegin(const C& c) {
    return c.get();
}
const int* cend(const C& c) {
    return cbegin(c) + c.size();
}

begin()/end() 是否应该同时具有const 和非const 重载？

    const int* begin() const {
        return get();
    }
    int* begin() {
        return get();
    }

还有其他需要考虑的事情吗？是否有工具/技术可以使这种“易于正确处理”并减少样板代码的数量？

---

一些相关的问题/讨论包括：

• Should custom containers have free begin/end functions?
• Why use non-member begin and end functions in C++11?
• When to use std::begin and std::end instead of container specific versions

Answer 1

我会选择C选项。

这里的主要问题是 std::begin() 实际上并不能用于使用 ADL 查找非成员 begin()。所以 真正的 解决方案是编写你自己的：

namespace details {
    using std::begin;

    template <class C>
    constexpr auto adl_begin(C& c) noexcept(noexcept(begin(c)))
        -> decltype(begin(c))
    {
        return begin(c);
    }
}

using details::adl_begin;

现在，无论您将begin() 编写为成员函数还是非成员函数都没有关系，只需在任何地方使用adl_begin(x)，它就可以正常工作。以及标准容器和原始数组。这方便地避开了成员与非成员的讨论。

---

是的，如果你想公开const 和非const 访问权限，你应该拥有begin() 和朋友的const 和非const 重载。

Answer 2

如果您希望类接口与 STL 一致，有一个标准描述了您的类接口应该是什么样子。 C++ 有这种“概念”的概念，它确定了给定类的要求是一个概念的充分实现。这几乎成为了 c++11 的语言特性。

您可能感兴趣的一个概念是Container 概念。如您所见，为了满足 Container 概念的要求，您需要 begin、cbegin、end 和 cend 作为成员函数（等等）。

由于您将数据存储在数组中，因此您可能还对SequenceContainer 感兴趣。

Answer 3

我建议创建两组函数——成员函数和非成员函数——以实现最大的灵活性。

namespace JDanielSmith {
   class C
   {
      const size_t _size;
      const std::unique_ptr<int[]> _data;

      public:
      C(size_t size) : _size(size), _data(new int[size]) {}

      inline const int* get() const { return _data.get(); }
      inline int* get() { return _data.get(); }

      size_t size() const { return _size; }

      int* begin() { return get(); }
      int* end() { return get() + _size; }
      const int* begin() const { return get(); }
      const int* end() const { return get() + _size; }
      const int* cbegin() const { return get(); }
      const int* cend() const { return get() + _size; }

   };

   int* begin(C& c) { return c.begin(); }
   int* end(C& c) { return c.end(); }
   const int* begin(C const& c) { return c.begin(); }
   const int* end(C const& c) { return c.end(); }
   const int* cbegin(C const& c) { return c.begin(); }
   const int* cend(C const& c) { return c.end(); }
}

如果您希望能够将C 类型的对象用作std::begin、std::end、std::cbegin 和std::cend 的参数，则成员函数是必需的。

如果您希望能够将C 类型的对象用作begin、end、cbegin 和cend 的参数，则非成员函数是必需的。 ADL 将确保为此类用途找到非成员函数。

int main()
{
   JDanielSmith::C c1(10);

   {
      // Non-const member functions are found
      auto b = std::begin(c1);
      auto e = std::end(c1);
      for (int i = 0; b != e; ++b, ++i )
      {
         *b = i*10;
      }
   }

   JDanielSmith::C const& c2 = c1;
   {
      // Const member functions are found
      auto b = std::begin(c2);
      auto e = std::end(c2);
      for ( ; b != e; ++b )
      {
         std::cout << *b << std::endl;
      }
   }

   {
      // Non-member functions with const-objects as argument are found
      auto b = begin(c2);
      auto e = end(c2);
      for ( ; b != e; ++b )
      {
         std::cout << *b << std::endl;
      }
   }
}

Answer 4

为了创建一个有效的迭代器，你必须确保 std::iterator_traits 是有效的。这意味着您必须设置迭代器类别。

迭代器应该实现 iterator()、iterator(iterator&&)、iterator(iterator const&)、operator==、operator !=、operator++、operator++(int)、operator*、operator= 和 operator->。如果可以的话，添加 operator

template <typename T>
class foo
{
public:

  using value_type = T;
  class iterator 
  { 
  public:
    using value_type = foo::value_type;
    using iterator_category = std::random_access_iterator_tag;
    // or whatever type of iterator you have...
    using pointer = value_type*;
    using reference = value_type&;
    using difference_type = std::ptrdiff_t;

    // ... 
  };

  class const_iterator 
  {
    // ... 
  };

  iterator begin() { /*...*/ }
  iterator end() { /*...*/ }

  const_iterator cbegin() const { /*...*/ }
  const_iterator cend() const { /*...*/ }

  /* ... */
};

请参阅：http://en.cppreference.com/w/cpp/iterator/iterator_traits，了解有关创建有效迭代器所需的更多信息。 （注意：您还需要某些属性才能成为有效的“容器”，例如 .size()）

理想情况下，您应该对 begin 和 end 使用成员函数，但这不是必需的……您也可以重载 std::begin 和 std::end。如果你不知道怎么做，我建议你使用成员函数。

你应该创建 begin() const 和 end() const，但它应该是 cbegin() 的别名，绝不与 begin() 相同！