STL容器迭代器和C指针迭代器有什么区别

Question

我正在编写一个反向迭代器，作为我自己的自定义矢量类的一部分。 到目前为止，我所写的内容如下。

class MyVector
{
  public:

  typedef T                           value_type;
  typedef value_type*                 pointer;
  typedef const value_type*           const_pointer;
  typedef value_type&                 reference;
  typedef const value_type&           const_reference;
  typedef pointer                     iterator;
  typedef const_pointer               const_iterator;
  typedef size_t                      size_type;

    class reverse_iterator
    {
        private:

        iterator iter;

        public:

        inline reverse_iterator(iterator a=0) : iter(a) {}
        inline reverse_iterator(const reverse_iterator& rev_iter) : iter(rev_iter.iter) {}
        inline reverse_iterator& operator++()
        {
            --iter;
            return *this;
        }
        // and remaining other operator functions
    };

  inline iterator begin (void) { return ((iterator)data_array);           }
  inline iterator end (void)   { return ((iterator)data_array+number_of_elements); }
  inline reverse_iterator      rbegin(void)    { return end()-1;}
  inline reverse_iterator      rend(void)      { return begin()-1;}


    //functions for myvector class 
}; //end of Myvector class

在上面的类中，iterater只是C风格的指针，而reverse_iterator是类。 所以当我做

    main()
    {
        myVector<int> i;
        myVector<int>::reverse_iterator rit= i.begin();
    }

我的reverse_iterator用begin（）函数初始化，代码正在编译并运行。 但这在STL的迭代器和reverse_iterator情况下不会发生。 它们阻止了这种初始化。 例如：reverse_iterator不允许使用begin（）函数初始化自己，而必须使用rbegin（）初始化。

那么我该怎么做才能避免这种初始化呢？ 我应该写一个像STL中一样的不同迭代器吗？ 而且我认为这是不可能的..请给我一些解决方案...

Answer 1

迭代器和反向迭代器有一些区别。

最明显的是：增加每个迭代器的方向是相反的。

不太明显： begin()的返回不是反向迭代器的结尾。 begin()-1将会是。 记住end()表示“一个过去”，因为C ++范围是半开的，即[begin，end）。 如果仅在反向迭代器中交换begin()和end() ，则反向迭代器将具有范围（开始，结束）。

换句话说，即使迭代器和反向迭代器本身在某些方面兼容，STL容器也具有begin()和end()以及rbegin()和rend()的原因是有原因的。

Answer 2

为了完全防止从iterator （指针）到reverse_iterator转换，请将reverse_iterator的构造reverse_iterator MyVector私有，并使MyVector成为reverse_iterator的朋友：

class MyVector
{
  // ...
  class reverse_iterator
  {
  private:
    friend class MyVector;
    reverse_iterator(iterator a=0) : iter(a) {}
    // ...
  };
  // ...
};

如果您希望该转换可用，但不是自动转换，则只需使相应的构造函数explicit 。

class MyVector
{
  // ...
  class reverse_iterator
  {
  public:
    explicit reverse_iterator(iterator a=0) : iter(a) {}
    // ...
  };
  // ...
};

在不相关的说明中，我还注意到，您对rbegin()可能会调用未定义的行为（我不能确定，因为这取决于初始化data_array的代码）：不允许将指针递减到数组。

顺便说一句，关键字inline在您的情况下不是必需的。 如果您在类定义内编写成员函数主体，则会自动内联。 当然， inline也不会有任何伤害。