c++ - 将指针复制到分配的内存

Question

这是一个一般性的编程问题，我希望答案将提供解决问题的替代方法，而不是快速修复或黑客攻击。我有两个对象，每个对象都有一些指向已分配内存的指针。我想将一些内部信息从一个对象复制到另一个对象。由于信息量很大，我只想复制指针。问题是当调用两个对象的析构函数时，它们各自调用内部信息(现在在两个对象中)的析构函数。这导致析构函数在同一个指针上被调用两次。

因为这是一个相当复杂的场景，向您展示整个代码是不切实际的。我设计了一个简单的例子来说明问题的根源。该代码在不复制任何数据的情况下附加两个预先存在的列表。如输出所示，析构函数在最后两个节点上被多次调用。 (一旦 K 被销毁，L 又一次被销毁，因为两个列表都有指向这些节点的指针)。

#include <iostream>

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

class List {
    public:
        List(const int);
        ~List();
        void append(const int);
        void append(const List&);
        void print()const;
    private:
        Node * head;
        Node * tail;
};

List::List(const int x)
{
    Node * q = new Node;
    q->data = x;
    q->next = 0;

    head = q;
    tail = q;
}

List::~List()
{
    while (head != 0){
        Node * temp = head->next;
        std::cout << "Deleting " << head->data << std::endl;
        delete head;
        head = temp;
    }
}

void List::append(const int x)
{
    Node * q = new Node;
    q->data = x;
    q->next = 0;
    tail->next = q;
    tail = q;
}

void List::append(const List& L2)
{
    this->tail->next = L2.head;
    this->tail = L2.tail;
}

void List::print()const
{
    for (Node * iter = head; iter; iter=iter->next){
        std::cout << iter->data << " ";
    }
    std::cout << std::endl;
}

int main()
{
    List L = List(1);
    L.append(3);
    std::cout << "List L:\n";
    L.print();

    List K = List(5);
    K.append(10);
    std::cout << "List K:\n";
    K.print();

    L.append(K);
    std::cout << "List L:\n";
    L.print();
}

输出是:

List L:
1 3 
List K:
5 10 
List L:
1 3 5 10 
Deleting 5
Deleting 10
Deleting 1
Deleting 3
Deleting 0
Deleting 39125056

Answer 1

不要使用指向节点的原始指针，而是使用 std::shared_ptr<Node>并删除明确的 delete从你的析构函数。只要存在 shared_ptr，共享指针就会将节点保存在内存中。在范围内指向它的实例。当不再有任何shared_ptr指向 Node 的实例, Node将被自动删除。