c++ - 析构函数删除函数中的拷贝返回动态结构

Question

好的大家，菜鸟问题。

所以我有一个实现单向链表的模板类。我程序中某个类中的函数返回这些列表之一。

psList<int> psObj::getList() const {
 return List;
}

所以发生的事情是在调用 return List 时，复制构造函数启动，它很好地完成了它的工作并创建了列表的拷贝。然而，函数完成并超出范围并调用析构函数!突然之间，返回的链表被删除了，因为这是我的析构函数所做的，删除一个列表并将其删除。

我知道我可以让返回类型成为一个指向复制列表头部的指针，一切都会很好，但问题是我仍然无法创建一个返回动态结构拷贝的函数，即使我想要，而且我确实想要。

我被要求提供更多代码。

这里是拷贝构造函数，显然是做深拷贝

template<class psClass>
psList<psClass>::psList(const psList &original) {
    head = NULL;

    if(original.head != NULL) {
        psNode<psClass>* iterator = original.head;
        while(iterator != NULL) {
            pushback(iterator->data);
            iterator = iterator->next;
        }
    }
}

这里是析构函数

template<class psClass>
psList<psClass>::~psList() {
    erase();
}

这里是析构函数调用的删除函数。

template<class psClass>
void psList<psClass>::erase() {
    psNode<psClass>* iterator = head;
    psNode<psClass>* buff;

    while(iterator != NULL) {
        buff = iterator->next;
        delete iterator;
        iterator = buff;
    }
}

所以是的，我正在做深度复制和深度破坏。问题不在于深度。问题是这样的。在原始函数中，制作并返回深拷贝。该函数超出范围，并在拷贝上调用深度析构函数。不再复制。

为了更好地解释这里是它在调试器中的样子

getlist 函数调用前的原始列表。

head 0x616080
data 2
next 0x616060
data 12
next 0x0

这里是getList函数内部一次“返回列表”的列表

head 0x616080
data 2
next 0x616060
data 12
next 0x0

同样的事情。

这里是复制构造函数末尾的列表“original”和“this”。

“这个”

head 0x63c900
data 2
next 0x63a940
data 12
next 0x0

“原创”

head 0x616080
data 2
next 0x616060
data 12
next 0x0

一切看起来都很棒不是吗。

现在我们回到了 getList 函数，即将进入最后的括号。

psList<int> psObj::getList() const {
 return List;
} // This bracket

此函数中返回的列表 List 就是您所期望的

head 0x616080
data 2
next 0x616060
data 12
next 0x0

现在我们进入最后一个括号，析构函数被调用

/* 
 * No idea what the in chrg thing is or why the debugger is telling me it was
 * optimized out but I mentioned it here cause maybe it has something to do with my
 * problem
 */
this 0x7ffffffe650
__in_chrg value optimized out

// Look familiar? well it should cause it is the head of the list I returned.
head 0x63c900 
data 2
next 0x63a940
data 12
next 0x0

然后砰!我刚刚复制并返回的列表被析构函数删除，因为它超出了范围。

在绕道之后重申我原来的问题。如何使用深拷贝获取函数返回的动态结构，而不用析构函数破坏所述拷贝。

应要求提供更多代码

// Simple single link node with default constructor initializing the link to NULL.
template <class psClass>
struct psNode {
    psClass data;
    psNode<psClass>* next;

    psNode() {
        next = NULL;
    }
};

和回推功能

template<class psClass>
void psList<psClass>::pushback(psClass object) {
    psNode<psClass>* ptr = new psNode<psClass>;
    ptr->data = object;

    if(head == NULL)
        head = ptr;
    else {
            //Have to find the tail now
        psNode<psClass>* tail;
        psNode<psClass>* iterator = head;
        while(iterator != NULL) {
            tail = iterator;
            iterator = iterator->next;
        }
        tail->next = ptr;
    }
}

是的，我知道跟踪尾部会更容易。

这是 psList 类定义:

template <class psClass>
class psList {
public:
    psList();
    ~psList();
    psList(const psList &original);
    psList(psNode<psClass>* _head);

    void erase();
    void pushfront(psClass object);
    void pushback(psClass object);
    bool isEmpty() const;
    psNode<psClass>* front() const;

private:
    psNode<psClass>* head;
};

还没有重载的赋值运算符。打算跨过这道坎后再加入。

Answer 1

psList 的复制构造函数似乎生成了一个浅拷贝而不是深拷贝。一般来说，如果您在一个类中管理资源，那么您需要非平凡的复制构造函数、赋值运算符和析构函数(“三巨头”)。请告诉我们psList的代码。