C++ 链表存在方法

我的exist方法有问题。
我在列表中查找int，如果它在列表中，它可以工作，但如果不在列表中，它就不能工作，我会收到一个运行时错误，说它停止工作。

有一个包含两个类的类列表：Node和Iterator。 代码在这里

    class List {
private:
    class Node {
    public:
        Node(int d, Node *n = NULL, Node *p = NULL)
            : data(d), next(n), prev(p) {}

        int data;
        Node *next;
        Node *prev;
    };

public:
    class Iterator {
    public:
        int next_element() {
            int to_be_returned = current->data;
            current = current->next;
            return to_be_returned;
        }
        bool has_more_elements() {
            return current != NULL;
        }
    private:
        Node *current;
        Iterator(Node* n) { current = n; }
        friend class List;
    };

public:
    List();
    ~List();
    void print();
    void push_front(int x);
    void push_back(int x);
    void clear();
    bool exists(int x);
    Iterator get_iterator() {
        return Iterator(_head);
    }
private:
    Node* _head;
    Node* _last;
};

List::List() {
    _head = NULL;
    _last = NULL;
}

void List::print() {
    for (Node* p = _head; p != NULL; p = p->next)
        cout << p->data << ' ';
}

void List::push_front(int x) {
    Node *new_node = new Node(x);
    new_node->next = _head;
    if (_head != NULL)
        _head->prev = new_node;
    _head = new_node;
    if (_last == NULL)
        _last = new_node;
}

void List::push_back(int x) {
    if (_head == NULL)
        push_front(x);
    else {
        Node *new_node = new Node(x);
        new_node->prev = _last;
        _last->next = new_node;
        _last = new_node;
    }
}

List::~List() {
    clear();
}

void List::clear() {
    Node *p = _head;
    while (p != NULL) {
        Node *q = p;
        p = p->next;
        delete q;
    }
    _head = NULL;
    _last = NULL;
}

bool List::exists(int x){
    Iterator it = this->get_iterator();
    while(it.current->data!=x && it.has_more_elements())
        it.current=it.current->next;
    return (it.current->data==x)?true:false;
}

类列表{
私人：
类节点{
公众：
节点（int d，节点*n=NULL，节点*p=NULL）
：数据（d），下一个（n），上一个（p）{
int数据；
节点*下一步；
节点*prev；
};
公众：
类迭代器{
公众：
int next_元素（）{
返回的int=当前->数据；
当前=当前->下一步；
返回到被返回的对象；
}
布尔有更多的元素（）{
返回电流！=NULL；
}
私人：
节点*电流；
迭代器（节点*n）{current=n；}
好友类列表；
};
公众：
List（）；
~List（）；
作废打印（）；
前推空（int x）；
无效推回（int x）；
无效清除（）；
bool存在（int x）；
迭代器get_迭代器（）{
返回迭代器（_头）；
}
私人：
节点*头；
节点*\u最后；
};
列表：：列表（）{
_head=NULL；
_last=NULL；
}
作废列表：：打印（）{
对于（节点*p=\u head；p！=NULL；p=p->next）
cout data next=_head；
如果（_head！=NULL）
_head->prev=新节点；
_head=新的_节点；
如果（_last==NULL）
_last=新的_节点；
}
无效列表：：推回（int x）{
如果（_head==NULL）
向前推（x）；
否则{
节点*新节点=新节点（x）；
新建节点->上一个=\u最后一个；
_last->next=新建_节点；
_last=新的_节点；
}
}
列表：：~List（）{
清除（）；
}
无效列表：：清除（）{
节点*p=_头；
while（p！=NULL）{
节点*q=p；
p=p->next；
删除q；
}
_head=NULL；
_last=NULL；
}
布尔列表：：存在（int x）{
迭代器it=this->get_Iterator（）；
而（it.current->data！=x&&it.has\u more\u elements（））
it.current=it.current->next；
返回（it.current->data==x）？真：假；
}

这是我的主要任务

intmain（）{
清单l；
l、 推回（86）；
l、 向前推（43）；
l、 向前推（12）；
如果（l.存在（1））{
cout在访问指针指向的数据之前，您应该检查指针是否指向nullptr（请参见
有更多元素（）
）。更好的命名可能会避免一些混淆

   while(it.current->data!=x && it.has_more_elements())
    it.current=it.current->next;
return (it.current->data==x)?true:false;

如果
x
不存在并且
x
到达列表末尾，
it.current->data
将导致运行时错误，因为
x
可能为
NULL

 while(it.has_more_elements() && it.current->data!=x)
   it.current = it.current->next;
 return it.current!=NULL;

@AliSamie：定义“不工作”可能更清楚，例如，调试器告诉你什么？我只是在重写代码时犯了一个错误，它现在可以工作了
 while(it.has_more_elements() && it.current->data!=x)
   it.current = it.current->next;
 return it.current!=NULL;