主页 / 问题 / 1607645
Accepted
Андрей Асафов
Asked:2025-02-25 07:59:16 +0000 UTC2025-02-25 07:59:16 +0000 UTC

我不明白如何实现列表的迭代器[关闭]

  • 772

任务是实现一个单链表，其最后一个元素指向第一个元素。

总体来说，列表如下：

template<typename T>
class Forward_list
{
  T data_;
  Forward_list<T>* next_;
};

迭代器如下所示：

class iterator
{
  Forward_list<T>* node_;
};

问题是我不知道如何编写一个函数end()来指向列表的最后一个元素，以便可以方便地使用它<algorithm>。

现在代码看起来很糟糕，很多东西都缺失了，我理解，如果你责骂它，我会很高兴，这样它会变得更好https://gist.github.com/shycoshy/b39ce63ea19984ee2a3073d0a1c1075e

如果您仅push_back()在列表中使用它并尝试在帮助下输出它，那么它“有点工作”并且只是“吃掉”迭代器需要输出的最后一个元素end()。如果你指向最后一个元素，那么它实际上是一个指向开头的指针。

在开始或结束处不可能创建一个假结，因为这是另一个选项C：

c++

2 个回答

  1. Best Answer

    有必要引入额外的“某些东西”来限制枚举在到达最后一个元素时的重复次数。 “标记第一个元素”选项是HolyBlackCat提供的一个很好的解决方案。我成功存储了指向最后一个元素的指针。这是一个非常精简的实现，仅用于演示：

    #include <iostream>
#include <algorithm>

template<typename T>
class Forward_list {
    struct Node {
      T data_;
      Node* next_;
      Node(const T& data) : data_(data), next_(nullptr) {}
    };
  public:
    class const_iterator;

    Forward_list() : head_(nullptr), last_(nullptr) {}

    ~Forward_list() {
      clear();
    }

    void push_back(const T& value) {
      Node* new_node = new Node(value);
      if (!head_) {
        head_ = new_node;
        last_ = new_node;
        new_node->next_ = head_; // Указываем на себя
      } else {
        last_->next_ = new_node;
        new_node->next_ = head_;
        last_ = new_node;
      }
    }

    void clear() {
      if (!head_)
        return;
      Node* current = head_;
      Node* next_node;
      do {
        next_node = current->next_;
        delete current;
        current = next_node;
      } while (current != head_);
      head_ = nullptr;
      last_ = nullptr;
    }

    const_iterator begin() const {
      return const_iterator(head_, last_);
    }

    const_iterator end() const {
      return const_iterator(nullptr, last_); // Указываем на nullptr для конца
    }

    class const_iterator {
      public:
        const_iterator(Node* node, Node* last) : current_(node), last_(last) {}

        const T& operator*() const {
          return current_->data_;
        }

        const_iterator& operator++() {
          if (current_ && current_ != last_) {
            current_ = current_->next_;
          } else {
            current_ = nullptr;
          }
          return *this;
        }

        bool operator!=(const const_iterator& other) const {
          return current_ != other.current_;
        }

        bool operator==(const const_iterator& other) const {
          return current_ == other.current_;
        }

      private:
        Node* current_;
        Node* last_; // Храним указатель на последний элемент
    };

  private:

    Node* head_;
    Node* last_;
};

int main() {
  Forward_list<int> list;
  list.push_back(1);
  list.push_back(2);
  list.push_back(3);
  // Используем стандартный алгоритм
  std::for_each(list.begin(), list.end(), [](int value) {
    std::cout << value << " ";
  });
  std::cout << std::endl;
  return 0;
}

    将打印：1 2 3

    此处在线。

    • 1

  2. 向迭代器添加一个等于true第一个元素的标志，并将其重置为false任意增量。也比较==一下这个标志。

    • 0

相关问题