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

Question

（另请参见是否有一种好方法可以不在C中手工编写自定义类型所需的所有12个容器函数？）

对于类，例如

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; }
};
}

公开迭代的首选方式是什么？我应该编写start（）/end（）（和cstart（）/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();
}

是否应该同时具有常量和非常量重载？

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

还有什么需要考虑的吗？是否有工具/技术可以使这一点“很容易正确”并减少锅炉铭牌代码的数量？

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

• 自定义容器是否应该具有自由开始/结束功能
• 为什么在C 11中使用非成员begin和end函数
• 何时使用std：：begin和std：：end而不是容器特定版本

Answer 1

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

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的对象用作参数，则必须使用成员函数。

如果您希望能够将类型为C的对象用作参数，仅用于开始、结束、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 2

我选择C选项。

这里的主要问题是，对于使用ADL查找非成员，std：：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\u begin（x）就可以了。以及标准容器和原始阵列。这方便地避开了成员与非成员的讨论。

是的，如果您想公开const和non-code>const访问权限，您应该拥有begin（）和friends的const和non-code重载。

Answer 3

如果希望类接口与STL一致，那么有一个标准描述类接口的外观。C有这样一个“概念”的概念，它规定了给定类的需求，以充分实现一个概念。这几乎成为c 11中的一个语言特性。

您可能感兴趣的一个概念是容器概念。如您所见，为了满足容器概念的要求，您需要开始、cstart、end和cend作为成员函数（除其他外）。

因为看起来您正在将数据存储在一个数组中，所以您可能还对SequenceContainer感兴趣。