C++类中的迭代器

Question

I have the following class:

 class list {
      private:
        struct node {
          node() { data=T(); prev=next=this; }
          ˜node() {}
          T data;
          node *prev;
          node *next;
        };
      public:
        class iterator {
        public:
          iterator() : p(NULL) {}
          T & operator*() { return p->data; }
          iterator & operator++()
            { p = p->next; return *this; }
          iterator & operator++(int)
            { iterator tmp = *this; ++*this; return *tmp; }
          bool operator==(const iterator & rhs) const
            { return p == rhs.p; }
          bool operator!=(const iterator & rhs) const
            { return p != rhs.p; }
        private:
          friend class list<T>;
          iterator(node *p) : p(p) {}
          node *p;
        };
        iterator begin() { return iterator(head->next); }
        iterator end() { return iterator(head); }
        list();
        ˜list();
        etc ...
      private:
        int N;
        node *head;
        node *findnode(int);
    };

我看到begin()函数返回一个迭代器类的构造函数。这是否意味着调用时会创建一个新的迭代器？如果是，那么当分配给这个迭代器的变量超出范围后，内存会被回收吗？我有点困惑，因为迭代器构造函数没有返回类型。如果有人能解答我的问题，我将不胜感激。

- Algonomaly

---

你应该在迭代器的构造函数和析构函数中添加调试语句，并在一个简单的程序中观察它的行为。 - didierc

旁注：operator++(int) 应该返回 tmp; 而不是 *tmp;。 - Robᵩ

Answer 1

在调用begin时会创建一个新的迭代器。就高层来说，当迭代器超出其范围时，它所占用的内存将被回收利用。

构造函数没有返回类型，因为它们是直接在要初始化的内存上调用的。

在较低层面上，声明在堆栈上的变量在超出其范围时会调用其析构函数，这是"回收"的一种方面。它们所占用的内存位于堆栈而不是堆上（如果调用了new，则会在堆上分配），因此在释放内存的意义上不会执行delete或垃圾回收。相反，变量所占用的内存可能会闲置一段时间，或者在超出其范围后立即被覆盖，这取决于在其超出范围后是否立即删除堆栈帧或添加堆栈帧（即函数是否沿堆栈返回或是否进行新的调用）。

- Josh Heitzman