C++链表赋值运算符问题

Question

我正在编写有序链表类定义 (OLList)。我已经编写了赋值运算符函数，但是当我尝试通过链接赋值操作来测试它时，程序陷入了 OLList::copy 函数的 while 循环。我知道这一点，因为我使用控制台打印进行了测试。

//OLList.h
struct Node {
  ListItem item;
  Node *next;
};

class OLList {
  public:
  OLList& OLList::operator =(const OLList& rhs)
  {
    if (this != &rhs) {
        destroy();
        copy(rhs);
    }
    return *this;
  }

  void OLList::destroy()
  {
    Node *current_node = this->headM;
    Node *next_node;
    while(current_node->next != nullptr)
    {
        next_node = current_node->next;
        delete(current_node);
        current_node = next_node;
    }


    return;
  }

void OLList::copy(const OLList& source)
  {
    Node *new_node, *current_node;
    Node *current_source_node = source.headM;
    this->headM->item = source.headM->item;
    current_node = this->headM;

    while(current_source_node->next != nullptr)
    {
        new_node = new(Node);
        current_node->next = new_node;
        current_node = current_node->next;
        current_source_node = current_source_node->next;
        current_node->item = current_source_node->item;
    }

    return;
  }
}

下面是用于测试类的代码。我已确保 print() 函数工作正常，所以这绝对不是问题。

//main.cpp
int main()
{
    OLList the_list;
    the_list.insert(1);
    the_list.insert(2);

    OLList second_list;
    second_list.insert(3);
    second_list.insert(4);

    OLList third_list;
    third_list.insert(5);
    third_list.insert(6);

    third_list = second_list = the_list;
    third_list.print();
}

编译运行时，程序永远不会终止，因为它陷入了上述循环。

Answer 1

如果 headM 为 nullptr，您的 destroy() 方法将失败。您应该使用 while(current_node != nullptr) 而不是 while(current_node->next != nullptr)。但更重要的是，它不会在销毁列表后将 headM 重置为 nullptr。所以在operator=调用destroy()之后，headM不再处于copy()的有效状态使用。

您的 copy() 方法同样不检查源或目标 headM 是否为 nullptr。但更重要的是，它假设目标列表事先是空的，否则如果它没有彻底崩溃(如上)，它就会泄漏内存。坦率地说，将一个列表复制到另一个列表通常只是编码不正确。

因此，您的代码正在调用未定义的行为，这任何事情都可能发生。

就像@PaulMcKenzie 在评论中所说的那样，你真的应该使用一个合适的复制构造函数来代替(和一个析构函数——因为你显然使用的是 C++11 或更高版本，所以也应该使用移动构造函数和移动赋值运算符——参见Rule of 5)。然后可以使用您的复制构造函数来实现您的赋值运算符(对于移动赋值也是如此)。

尝试更像这样的东西:

struct Node {
    ListItem item;
    Node *next = nullptr;

    Node(const ListItem &value) : item(value) {}
};

class OLList {
private:
    Node *headM = nullptr;

public:
    OLList() = default;

    OLList(const OLList &src)
    {
        Node *current_source_node = src.headM;
        Node **current_node = &headM;

        while (current_source_node)
        {
            *current_node = new Node(current_source_node->item);
            current_node = &((*current_node)->next);
            current_source_node = current_source_node->next;
        }

        /* alternatively:
        Node *current_source_node = src.headM;
        while (current_source_node) {
            insert(current_source_node->item);
        }
        */
    }

    OLList(OLList&& src)
    {
        src.swap(*this);
    }

    ~OLList()
    {
        Node *next_node;    

        while (headM)
        {
            next_node = headM->next;
            delete headM;
            headM = next_node;
        }
    }

    void clear() {
        OLList().swap(*this);
    }

    OLList& operator=(const OLList& rhs)
    {
        if (this != &rhs) {
            OLList(rhs).swap(*this);
        }
        return *this;
    }

    OLList& OLList::operator=(OLList&& rhs)
    {
        OLList(std::move(rhs)).swap(*this);
        return *this;
    }

    void swap(OLList &other) {
        std::swap(headM, other.headM);
    }

    void insert(const ListItem &value) {
        ...
    }

    void print() const {
        ...
    }
    ...
};