c++ - 如何将默认迭代器写入通用列表？

Question

我正在将这段代码写成一个通用列表，现在在这个通用列表中，我为迭代器做了一个类，它包含两个参数:一个是指向他指向的列表的指针。另一个指向他指向的列表中的元素..

现在我需要编写一个插入函数，将新元素插入到给定列表中，规则如下:::我将新节点插入列表的位置，如果迭代器指向列表的末尾，则在此函数中列出我们将新节点添加到列表的末尾，否则我们将节点插入迭代器当前指向的节点之前的一个位置，如果 iteratot 指向不同的节点，那就是一个错误。

现在我希望迭代器是默认的，所以如果在测试中有人用一个参数调用函数，我希望迭代器等于列表的末尾元素。函数结束我把它写在列表里面。现在在插入函数中我这样做了但是我得到了这个错误:

cannot call member function "List::iterator List::end()"without object .

#include <iostream>
#include <assert.h>
#include "Exceptions.h"

template <class T>
class List {

public:
    List();
    List(const List&);
    ~List();
    List<T>& operator=(const List& list);
    template <class E>
    class ListNode {
        private:
             ListNode(const E& t, ListNode<E> *next): data(new E(t)), next(next){}
             ~ListNode(){delete data;}
             E* data;
             ListNode<E> *next;
        public:
            friend class List<E>;
            friend class Iterator;
            E getData() const{
               return *(this->data);
            }
            ListNode<E>* getNext() const{
               return this->next;
            }
            };
    class Iterator {
        const List<T>* list;
        int index;
        ListNode<T>* current;
        Iterator(const List<T>* list, int index): list(list),
                index(index),current(NULL){
            int cnt=index;
            while (cnt > 0) {
                current = current->next;
                cnt--;
                    }
        }
        friend class List<T>;
        friend class ListNode<T>;
    public:
       // more functions for iterator
    };
    Iterator begin() const ;
    Iterator end() const;
    void insert(const T& data, Iterator iterator=end());//here i get the error
    void remove(Iterator iterator);
    class Predicate{
    private:
      T target;
    public:
      Predicate(T i) : target(i) {}
      bool operator()(const T& i) const {
        return i == target;
      }
    };
    Iterator find(const Predicate& predicate);
    class Compare{
    private:
      T target;
    public:
      Compare(T i) : target(i) {}
      bool operator()(const T& i) const {
        return i < target;
      }
    };
    bool empty() const;
    int compareLinkedList(ListNode<T> *node1,  ListNode<T> *node2);

private:
   ListNode<T> *head;
   ListNode<T> *tail;
int size;
};

任何帮助都会很棒!因为我不知道为什么会出现这样的错误。

//insert function just in case : 


template <typename T>
void List<T>::insert(const T& data, Iterator iterator=end()){
    if(iterator.list!=this){
        throw mtm::ListExceptions::ElementNotFound();
        return;
    }
    ListNode<T> *newNode = new ListNode<T>(data, iterator.current);
    if(iterator.index==size){
        if (head == NULL) {
            head = newNode;
            tail=newNode;
            }else{
        Iterator temp(this,size-1);
        temp.current->next=newNode;
            }
        //newNode->next=this->end().current;
           }
    else {
    if (head == NULL) {
    head = newNode;
    tail=newNode;
    }
   else {
       Iterator temp1(this,iterator.index-1);
        temp1.current->next=newNode;
        newNode->next=iterator.current->next;
   }

   }
    size++;
}

Answer 1

void insert(const T& data, Iterator iterator=end());

这是违规行。默认参数不能是成员函数调用的结果。实现您想要的目标的正确工具是重载。

void insert(const T& data, Iterator iterator);
void insert(const T& data) { insert(data, end()); }

这里我们仍然遵循您实现的插入函数，但我们在允许的重载主体内调用 end。

不用担心间接调用。这是在类声明本身内部定义的一个非常小的函数。任何像样的编译器都会将其完全内联。