Question

我试图搜索主题，但我发现循环使用的所有线程。但是我想以递归的方式做到这一点：

template <typename S>
struct node {
    S data;
    node<S> * next; 
};

这是我在析构函数中调用的函数（将头部作为参数传递）：

void destroy(node<T> * n) {
    if(n->next != NULL){
        destroy(n->next);
    }
    delete n;
}

不幸的是，结果是分段错误。有人能帮助我吗？

编辑：完整代码

#include <iostream>

using namespace std;


template <typename T>
class List {
    private:

    template <typename S>
    struct node {
        S data;
        node<S> * next; 
    };

    node<T> * first;

    node<T> * get_last_p() {
        if(first != NULL){
            return get_last(first);
        }
        return NULL;
    }

    node<T> * get_last(node<T> * n) {
        if(n->next != NULL) {
            return get_last(n->next);
        } else {
            return n;
       }
       return NULL;
    }

    void destroy(node<T> * n) {
        if(n->next != NULL){
            destroy(n->next);
        }  
        delete n;
    }


    public:

    List() {first->next = 0;}
    ~List() {destroy(first);}

    void add(T element) {
        node<T> * new_element = new node<T>;
        new_element->data = element;
        if(first == NULL){
            first = new_element;
        } else {
            get_last_p()->next = new_element;
        }
    }

    T get_last() {
        return get_last_p()->data;
    }

    T get_first() {
        return first->data;
    }

};

Answer 1

从我所看到的，在List的构造函数中，first未初始化，然后立即被访问。这是未定义的行为。即使first以某种方式以不可靠的方式初始化为null，并且first->next = 0;不会以某种方式崩溃，您也会在析构函数{{1}中失败}，因为destroy假定其原始参数不为空。

我认为你的意思是 destroy

如果List() : first{ new node{} } { first->next = nullptr; }无意保留值，那么您必须重构代码才能首先将first初始化为null - 那里没有解决方法 - 并在所有代码中明确处理first为空的情况。您不能指定空，无效或未定义指针的first。

链表的递归析构函数

1 个答案: