Question

我正在尝试实现一个链表，我完全迷失了。我在整个地方得到了断点，特别是擦除方法。每当我改变擦除方法时，一些错误将不可避免地出现。我有指针错误，析构函数问题只有在调用erase方法时才会出现，等等。

这是我到目前为止所拥有的：

标题文件：

#pragma once

class IntList {
private:

    class IntNode {
    public:
        IntNode(int v, IntNode *pr, IntNode *nx);
        ~IntNode();
        IntNode* previous;
        IntNode* next;

        class iterator {

        public:
            iterator(IntNode* t);
            int& operator*();
            iterator& operator++();
            iterator& operator--();
            bool operator!=(iterator other)const;
        private:
            IntNode* target;
        };

    private:
        int value;
    };

    IntNode* head;
    IntNode* tail;
    int count;

public:

    IntList();
    ~IntList();
    void push_back(int v);
    void pop_back();
    int size() const { return count; }
    typedef IntNode::iterator iterator;
    iterator begin();
    iterator end();
    //unsigned int size() const;
    void push_front(int value);
    bool empty() const;
    int& front();
    int& back();
    void clear();
    iterator erase(iterator position);
};

实现：

#include "IntList.h"
#include <stdexcept>

IntList::IntList() : head{ nullptr }, tail{ nullptr }, count{ 0 }
{}

IntList::~IntList() {
    while (head) {
        head = head->next;
        delete head;
    }
}

void IntList::push_back(int v) {
    tail = new IntNode{ v, tail, nullptr };
    if (!head) { head = tail; }
    count += 1;
}

void IntList::pop_back() {
    tail = tail->previous;
    delete tail->next;
    count -= 1;
}

IntList::iterator IntList::begin()
{
    return iterator{ head };
}

IntList::iterator IntList::end() {
    return iterator{ nullptr };
}

void IntList::push_front(int value) {
    head = new IntNode{ value, nullptr, head };
    if (!tail) { tail = head; }
    count += 1;
}

bool IntList::empty() const{
    return (count==0);
}

int& IntList::front() {
    return *begin();
}

int& IntList::back() {
    return *begin();
}

void IntList::clear() {
    head = nullptr;
    tail = nullptr;
    count = 0;
}

IntList::iterator IntList::erase(iterator position) {

    int midpointL = 0;

    for (iterator index = begin(); index != position; ++index) {
        midpointL++;
    }

    if (midpointL == 0) {
        head = head->next;
    }
    else if (midpointL == count) {
        tail = tail->previous;
    }
    else {

        // Move head to get a reference to the component that needs to be deleted
        for (int i = 0; i < midpointL; i++) {
            head = head->next;
        }

        // Change the previous and next pointers to point to each other
        (head->previous)->next = (head->next);
        (head->next)->previous = (head->previous);

        for (int i = midpointL-1; i > 0; i++) {
            head = head->previous;
        }

    }

    count-=1;

    return position;
}


IntList::IntNode::IntNode(int v, IntNode * pr, IntNode * nx)
    : previous{ pr }, next{ nx }, value{ v }
{
    if (previous) { previous->next = this; }
    if (next) { next->previous = this; }
}

IntList::IntNode::~IntNode() {
    if (previous) previous->next = next;
    if (next) next->previous = previous;
}

IntList::IntNode::iterator::iterator(IntNode* t)
    : target{ t }
{}

int& IntList::IntNode::iterator::operator*() {
    if (!target) { throw std::runtime_error{ "Deferenced sentinel iterator." }; }
    return target->value;
}

IntList::IntNode::iterator& IntList::IntNode::iterator::operator++()
{
    if (target) { target = target->next; }
    return *this;
}

IntList::IntNode::iterator& IntList::IntNode::iterator::operator--()
{
    if (target) { target = target->previous; }
    return *this;
}

bool IntList::IntNode::iterator::operator!=(iterator other)const
{
    return (!(target == other.target));
}

有人能帮我指出正确的方向吗？

谢谢！

Answer 1

让我们在这里快速回顾一下：

IntList::~IntList() {
    while (head) {
        head = head->next;
        delete head;
    }
}

你应该这样做：

IntList::~IntList() {
    while (head) {
        IntNode* newHead = head->next;
        delete head;
        head = newHead;
    }
}

正在删除＆＃34; next＆＃34;对象，然后你试图在下一次迭代中访问它。

void IntList::pop_back() {
    tail = tail->previous;
    delete tail->next;
    count -= 1;
}

这里你没有检查尾巴是否为空或是否指向头部...（空的情况是什么？），也许count!=0？如果您可以删除不存在的下一个节点

IntList::iterator IntList::end() {
    return iterator{ nullptr };
}

.. end为空？ ebd应该是你的尾巴...

int& IntList::back() {
    return *begin();
}

开始......不回来。

void IntList::clear() {
    head = nullptr;
    tail = nullptr;
    count = 0;
}

clear应该释放列表中的所有对象。你在这里生成垃圾（泄漏）。

我在这里停了下来，对不起，这只是一个喝咖啡休息时间。但你应该仔细看看： *空指针用法 *在不需要时删除您的节点列表项 *注意不要使用无效指针（如我在某处看到的head->previous->next）

您必须自下而上检查您的代码。希望这些初步提示可以帮助您完成学习过程。

玩得开心， STE

实施双重挂钩清单

1 个答案: