0

这是我的 C++ 代码:

#include <iostream>

using namespace std;

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

class LinkedList
{
private:
    Node* first;
    Node* last;
public:
    LinkedList() {first = last = NULL;};
    LinkedList(int A[], int num);
    ~LinkedList();

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

// Create Linked List using Array
LinkedList::LinkedList(int A[], int n)
{   
    Node* t = new Node;
    if (t == NULL)
    {
        cout << "Failed allocating memory!" << endl;
        exit(1);
    }
    t->data = A[0];
    t->next = NULL;
    first = last = t;

    for (int i = 1; i < n; i++)
    {
        t = new Node;
        if (t == NULL)
        {
            cout << "Failed allocating memory!" << endl;
            exit(1);
        }
        t->data = A[i];
        t->next = NULL;
        
        last->next = t;
        last = t;
    }
}

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

    while (p != NULL)
    {
        tmp = p;
        p = p->next;
        delete tmp;
    }
}

// Displaying Linked List
void LinkedList::Display()
{
    Node* tmp;

    for (tmp = first; tmp != NULL; tmp = tmp->next)
        cout << tmp->data << " ";
    cout << endl;    
}

// Merge two linked list
void LinkedList::Merge(LinkedList& b)
{
    // Store first pointer of Second Linked List
    Node* second = b.first;
    Node* third = NULL, *tmp = NULL;

    // 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
    if (first->data < second->data)
    {
        third = tmp = first;
        first = first->next;
        tmp->next = NULL;
    }
    else
    {
        third = tmp = second;
        second = second->next;
        tmp->next = NULL;
    }

    // Use while loop for repeating process until First or Second hit NULL
    while (first != NULL && second != NULL)
    {
        // If first Node data is smaller than second Node data
        if (first->data < second->data)
        {
            tmp->next = first;
            tmp = first;
            first = first->next;
            tmp->next = NULL;
        }
        // If first Node data is greater than second Node data
        else
        {
            tmp->next = second;
            tmp = second;
            second = second->next;
            tmp->next = NULL;
        }
    }

    // Handle remaining Node that hasn't pointed by Last after while loop
    if (first != NULL)
        tmp->next = first;
    else
        tmp->next = 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 != NULL)
    {
        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.last = NULL;
    b.first = 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);

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

    return 0;
}

我是 C++ 的初学者,在这段代码中,我练习如何合并两个链表。这实际上非常有效。我已经按排序顺序成功合并了两个链接列表。

但是,有人说我应该遵循C++的三法则。其中实现:DestructorCopy ConstructorCopy Assignment Operator

我看过很多关于那个的视频。我确实理解这基本上是处理浅拷贝,特别是当我们不希望两个不同的对象指向相同的内存地址时。但是,对于我的问题是,我仍然不知道如何在链接列表上工作的类上实现它,就像我上面的代码一样。

有人说,在我的 中main(),这段代码:l1.Merge(l2);不知何故不正确,因为我没有明确的复制构造函数。

如果你看我的Merge()函数,在最后一行,如果我没有这样做:b.last = NULL;b.first = NULL;,它只会破坏第二个链接列表的指针,编译器会给我警告:检测到双释放()

所以,我想我的问题是:

  1. 这段代码怎么会:l1.Merge(l2);与复制构造函数有关?
  2. Double free()因为我没有执行三法则吗?如果是,如何解决?
  3. 如何根据我的代码编写三法则?何时或如何使用它们?
  4. 根据本准则,有什么问题吗?如果我的程序只想合并链表,我还需要三法则吗?

谢谢你。我希望有人能像我10岁一样向我解释。并希望有人可以给我写一些代码。

4

2 回答 2

0

这段代码中应用了几个有问题的做法,并且还有一个错误。

首先,漏洞。当您创建一个列表时,它是它new的所有节点并使用指针跟踪它们。当您将一个列表分配给另一个列表时,您实际上是在复制指针值。您现在不仅丢失了分配列表的节点(因为您覆盖了它们)并且出现内存泄漏(因为现在没有指向分配节点的指针),您现在在两个不同的列表上也有相同的指针,指向相同的节点。当列表被销毁时,它们都会尝试访问delete它们的节点,最终你会释放相同的内存两次。玉。

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

然后,有问题的做法:

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

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

于 2021-07-16T18:07:04.603 回答
0

但是,对于我的问题是,我仍然不知道如何在链接列表上工作的类上实现[三规则],就像我上面的代码一样。

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

有人说,在我的 中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;
}

演示

于 2021-07-16T19:21:12.803 回答