在指定的自定义类迭代器位置插入节点

Question

我试图在指定位置插入一个节点，问题是插入发生在我想要的位置之后的一个位置。例如：

在list.insert(list.begin()++, 100) 插入 100 到 1,2,3,4,5,6,7 结果：

1,2,100,3,4,5,6,7

我想过递减迭代器，然后插入，但这将是一种解决方法，我的代码中有一些有缺陷的逻辑，但我看不到它在哪里。

插入函数

iterator insert(iterator position, const T& value) {

        Node* newNode = new Node(value);

        if (position == List<T>::iterator(head_)) {
            newNode->next_ = head_;
            head_ = newNode;
        }
        else if (!position.iNode->next_) {
            position.iNode->next_ = newNode;
        }
        else {

            Node* tmp = new Node(value);
            tmp->next_= position.iNode->next_;
            position.iNode->next_ = tmp;
        }

        return position;
    }

迭代器类

class iterator
    {
    public:

        Node* iNode;
        iterator(Node* head): iNode(head){ }
        ~iterator() {}


        T& operator*() {
            return  iNode -> value_;
        }
    
        iterator& operator++() {
            iNode = iNode->next_;
            return *this;
        }

        iterator operator++(int ignored) {
            iNode = iNode->next_;
            return *this;
        }

        //! Is this iterator pointing at the same place as another one?
        bool operator== (const iterator& it) const {
            return this->iNode == it.iNode;
        }

        //! Is this iterator pointing at a different place from another?
        bool operator!= (const iterator& it) const {
            return this->iNode != it.iNode;
        }
    };

节点类

class Node {
    public:
        Node(T value) : value_(value) {}

        T value_;
        Node* next_;
        Node* prev_;

        Node* head_;
        Node* tail_;
    };

Answer 1

插入中的问题：

iterator insert(iterator position, const T& value) {

        Node* newNode = new Node(value);

        if (position == List<T>::iterator(head_)) {
            newNode->next_ = head_;
            head_ = newNode;
        }
        else if (!position.iNode->next_) {
            position.iNode->next_ = newNode;
        }
        else {
            Node* curr = head_; 
            while (curr->next_ != position.iNode) 
                {
                    curr = curr->next_;
                }

            newNode->next_ = curr->next_;
            curr->next_ = newNode;
        }

        return position;
    }

在迭代器位置之后插入一个新节点。但是你需要在新节点之前插入它。

顺便说一句，我在自己的 List 类中测试过它。如果出现问题，只需在我的帖子中添加评论。

更新：实际上，我当时只修复了部分问题。现在的逻辑是：

1. 在迭代器之前从头到节点迭代。
2. 将新节点连接到我们在第一步中迭代到的下一个节点。
3. 将我们在第一步中迭代到的节点连接到新节点。