Question

所以我试图制作一个递归链表。看起来有点像这样：

class List  
{   int cur; //For now 
    List* nxt;

public:
    List()
        {cur = nullptr; nxt = nullptr;}
    ~List()
        {std::cout << "Destroyed\n";}

...

现在我有一个功能缺点，

List cons(const int &a)
{   if(cur == nullptr)
    {   cur = new int;
        *cur = a;
    }
    else
    {   List* x = new List;
        x->cur = new int;
        *(x->cur) = *cur;
        x->nxt = nxt;
        *cur = a;
        nxt = x;
    }
    return *this;
}

一位经营者，

std::ostream& operator<<(std::ostream& out, const List &b)
{   out << "Output\n";
    return out;
}

我在main中使用此代码来驱动它：

int main()
{   List a;
    std::cout << "Cons\n";
    a.cons(3);
    std::cout << "Cons\n";
    a.cons(2);
    std::cout << "Cons\n";
    a.cons(1);
    std::cout << a;
}

这样，在运行时会产生：

Cons
Destroyed
Cons
Destroyed
Cons
Destroyed
Out
Destroyed
Destroyed

我的问题是，
a，为什么在成员函数中调用析构函数，
b，为什么在const引用上调用析构函数，
而且，破坏者如何工作以及如何阻止我不断自杀呢？

干杯。

Answer 1

函数List cons(const int &a)返回*this的副本。这导致了一堆临时的List对象。

析构函数调用您看到的是从每次调用cons返回的副本。

提示：改为使用List& cons(int a)。

递归列表：所有调用析构函数的东西

1 个答案: