链表：如何实现析构函数、复制构造函数和复制赋值运算符？[已结束]

此代码中应用了几种有问题的做法，并且还存在一个错误。

首先，错误。当您创建列表时，它会包含其所有节点，并使用指针跟踪它们。当您将一个列表分配给另一个列表时，您实际上会复制指针值。您现在不仅丢失了已分配列表的节点（因为您覆盖了它们）并发生了内存泄漏（因为现在没有指向已分配节点的指针），您现在还在两个不同的列表中拥有相同的指针，指向相同的节点。当列表被销毁时，它们都会尝试访问它们的节点，而您最终会释放相同的内存两次。育。newdelete

此 bug 的解决方案是实现赋值运算符。

然后，有问题的做法：

1. using namespace std; (为什么“使用命名空间标准”被认为是不好的做法？)
2. 在构造函数正文中分配 的成员，而不是将值直接传递给初始化列表中的构造函数。（构造函数中这个奇怪的冒号成员 （“ ： ”） 语法是什么？LinkedList)
3. 声明数组参数 （） 就是声明指针。只要注意它。int[]
4. new不能再来了！检查其返回值是没有用的。如果它不能分配，它只会抛出异常。NULL
5. NULL是要使用的不合适的常量。您可以使用 ，它是 C++ 的等效项，但它是类型安全的。nullptrNULL
6. 手动内存管理是很棘手的（正如你自己发现的那样）。您可能有兴趣使用或减轻负担。他们会抓住这个错误。newdeletestd::unique_ptrstd::shared_ptr

现在，请：不要用 C++ 编写，就像用 C 编写带有类一样。我知道您可能没有遇到我在这里介绍的所有功能，但无论如何，现在您已经了解了它们:)

但是，因为我的问题是，我仍然不知道如何在一个在链表上工作的类上实现 [三分法则]，就像我上面的代码一样。

您只需实现复制构造函数和复制赋值运算符即可迭代输入列表，创建每个节点的副本并将它们插入到目标列表中。您已经有一个工作析构函数。对于复制赋值运算符，通常可以使用复制交换习语通过复制构造函数来实现它，以避免重复自己。

有人说，在我的 ，这段代码：在某种程度上是不正确的，因为我没有显式的复制构造函数。main()l1.Merge(l2);

然后你被告知错了。您的代码与复制构造函数无关。Merge()

如果你看一下我的函数，在最后一行，如果我没有这样做：和，它只是破坏了第二个链表的指针，编译器会给我警告：Merge()b.last = NULL;b.first = NULL;Double free() detected.

正确。由于要将节点从输入列表移动到目标列表，因此需要重置输入列表，使其不再指向移动的节点。否则，输入列表的析构函数将尝试释放它们，目标列表的析构函数也会尝试释放它们。

这个代码怎么可能与复制构造函数有关？l1.Merge(l2);

它与它没有任何关系。

是因为我没有执行三法则而发生的吗？Double free()

不在您的特定示例中，因为您没有执行任何复制操作。但是，一般来说，不实施三法则可能会导致双重自由，是的。

如何根据我的代码编写三法则？

请参阅下面的代码。

如果我的程序只想合并链表，我还需要三法则吗？

哈哈仅当您要复制列表时。

话虽如此，这里有一个包含三法则的实现：

#include <iostream>
#include <utility>

struct Node
{
    int data;
    Node *next;
};

class LinkedList
{
private:
    Node *first;
    Node *last;
public:
    LinkedList();
    LinkedList(const LinkedList &src);
    LinkedList(int A[], int num);
    ~LinkedList();

    LinkedList& operator=(const LinkedList &rhs);

    void Display() const;
    void Merge(LinkedList &b);
};

// Create Linked List using default values
LinkedList::LinkedList()
    : first(NULL), last(NULL)
{
}

// Create Linked List using Array
LinkedList::LinkedList(int A[], int n)
    : first(NULL), last(NULL)
{
    Node **p = &first;

    for (int i = 0; i < n; ++i)
    {
        Node *t = new Node;
        t->data = A[i];
        t->next = NULL;

        *p = t;
        p = &(t->next);

        last = t;
    }
}

// Create Linked List by copying another Linked List
LinkedList::LinkedList(const LinkedList &src)
    : first(NULL), last(NULL)
{
    Node **p = &first;

    for (Node *tmp = src.first; tmp; tmp = tmp->next)
    {
        Node* t = new Node;
        t->data = tmp->data;
        t->next = NULL;

        *p = t;
        p = &(t->next);

        last = t;
    }
}

// Deleting all Node in Linked List
LinkedList::~LinkedList()
{
    Node *p = first;

    while (p)
    {
        Node *tmp = p;
        p = p->next;
        delete tmp;
    }
}

// Update Linked List by copying another Linked List
LinkedList& LinkedList::operator=(const LinkedList &rhs)
{
    if (&rhs != this)
    {
        LinkedList tmp(rhs);
        std::swap(tmp.first, first);
        std::swap(tmp.last, last);
    }
    return *this;
}

// Displaying Linked List
void LinkedList::Display() const
{
    for (Node *tmp = first; tmp; tmp = tmp->next)
        std::cout << tmp->data << " ";
    std::cout << std::endl;
}

// Merge two linked list
void LinkedList::Merge(LinkedList& b)
{
    if ((&b == this) || (!b.first))
        return;

    if (!first)
    {
        first = b.first; b.first = NULL;
        last = b.last; b.last = NULL;
        return;
    }

    // Store first pointer of Second Linked List
    Node *second = b.first;
    Node *third, **tmp = &third;

    // We find first Node outside loop, smaller number, so Third pointer will store the first Node
    // Then, we can only use tmp pointer for repeating process inside While loop
    // Use while loop for repeating process until First or Second hit NULL
    do
    {
        // If first Node data is smaller than second Node data
        if (first->data < second->data)
        {
            *tmp = first;
            tmp = &(first->next);
            first = first->next;
        }
        // If first Node data is greater than second Node data
        else
        {
            *tmp = second;
            tmp = &(second->next);
            second = second->next;
        }
        *tmp = NULL;
    }
    while (first && second);

    // Handle remaining Node that hasn't pointed by Last after while loop
    *tmp = (first) ? first : second;

    // Change first to what Third pointing at, which is First Node
    first = third;  

    // Change last pointer from old first linked list to new last Node, after Merge
    Node *p = first;
    while (p->next)
    {
        p = p->next;
    }   
    last = p;
    
    // Destroy second linked list because every Node it's now connect with first linked list
    // This also prevent from Double free()
    b.first = b.last = NULL;
}

int main()
{
    int arr1[] = {4, 8, 12, 14, 15, 20, 26, 28, 30};
    int arr2[] = {2, 6, 10, 16, 18, 22, 24};
    int size1 = sizeof(arr1) / sizeof(arr1[0]);
    int size2 = sizeof(arr2) / sizeof(arr2[0]);
    
    LinkedList l1(arr1, size1);
    LinkedList l2(arr2, size2);
    LinkedList l3(l1);
    LinkedList l4;

    l1.Display();
    l2.Display();
    l3.Display();
    l4.Display();
    
    // Merge two linked list, pass l2 as reference
    l3.Merge(l2);
    l4 = l3;

    l1.Display();
    l2.Display();
    l3.Display();
    l4.Display();

    return 0;
}

演示