Question

我创建了一个名为BST的类，它有一个成员根。我知道当我调用解构器来分类BST时，它会删除root并释放该类占用的内存。

我想知道，解构器是否会解析与BST对象相关的所有节点。这是留下孩子和右孩子的根和他们的左右孩子等等。

我猜这是一个号码。在这种情况下，我认为我将不得不进行一个邮政订单遍历并手动删除每个节点。有没有办法一次做到这一点。没有走遍树节点

#ifndef BST_H
#define BST_H
#include "bst.h"
#include <stdio.h>
#include<iostream>

class bst
{
protected:
    struct node{

        node* p;
        node* lc;
        node* rc;
        int key;
        node(int x,node* p=nullptr,node* lc=nullptr,node* rc=nullptr):key(x){

        }
        ~node(){
        std::cout<<"decontrucotr node";
        }

    };
    node* nil=new node(0);
    node* root;


public:


    bst();
    virtual ~bst();
    void put(int x);
    void in_order(node* x);
    void in_order();
    void pre_order(node* x);
    void pre_order();




    private:
};

#endif // BST_H

函数在此

中定义

#include "bst.h"
#include <stdio.h>
#include<iostream>

bst::bst():root(nil)
{



}

bst::~bst()
{

std::cout<<"deconstructor tree"<<'\n';
}

void bst::put(int x)
{

node* k=new node(x,this->nil,this->nil,this->nil);
node* y=this->root;
node* p=y;
while (y != nil){

    p=y;
    if (y->key>x){
        y=y->lc;
    }
    else{
        y=y->rc;
    }
}
if (p==nil){
    this->root=k;
    k->lc=this->nil;
    k->rc=this->nil;
    k->p=this->nil;
}
else if(p->key>x){
    p->lc=k;
    p->lc->p=p;
    k=p->lc;
    k->lc=this->nil;
    k->rc=this->nil;
}
else{
    p->rc=k;
    p->rc->p=p;
    k=p->rc;
    k->lc=this->nil;
    k->rc=this->nil;
}
}

void bst::in_order(node* x){
if(x != nil){
this->in_order(x->lc);
printf("%d%c",x->key,'\t');
this->in_order(x->rc);
}
}
void bst :: in_order(){
this->in_order(this->root);
printf("%c",'\n');

}
void bst::pre_order(node* x){
    if(x!=this->nil){
    printf("%d%c",x->key,'\t');
    pre_order(x->lc);
    pre_order(x->rc);


}
}
void bst::pre_order(){
pre_order(this->root);

printf("%c",'\n');
}

Answer 1

我创建了一个名为BST的类，它有一个成员根。我知道当我调用解构器来分类BST时，它会删除root并释放该类占用的内存。

在您显示的实现中，~bst析构函数基本上是空的（日志记录不计算），它根本不会释放任何节点。

我想知道，解构器是否会解析与BST对象相关的所有节点。

bst对象本身被破坏。它的子节点不是，不。

是留下孩子和右孩子的根和他们的左右孩子等等。

不在当前的实施中，没有。你需要编写那个逻辑。

在这种情况下，我认为我将不得不进行邮政订单遍历并手动删除每个节点。

在当前的实施中，是的。

有没有办法一次完成。没有走遍树节点

或者：

编码~node析构函数以删除其直接子节点。然后~bst析构函数可以删除其root节点，并且其下的所有其他节点将被递归删除。
使用智能指针，例如std::unique_ptr，而不是原始指针。让编译器为您完成所有工作。

Answer 2

＆＃34;我是否必须手动解构所有对象？＆＃34;

是的，因为C / C ++没有跟踪内存，你告诉它你要自我管理，这就是使用new和/或malloc暗示的内容。

如果您需要，there are options用于不同的用例。但是，除此之外，您必须始终将每个分配（new）与1个重新分配（delete）配对。

＆＃34;我想知道，解构器是否会解构与BST对象相关的所有节点？＆＃34;

不，因为你没有告诉它。

你应该：

~node()
{
    std::cout<<"decontrucotr node";
    delete lc;
    delete rc;
}

那就是说bst::put(int x)对我来说毫无意义，我发现它中很可能存在类似的错误。您应该努力编写记录清晰的代码 - 特别是如果您打算向其他人寻求帮助。

我是否必须手动解构所有对象

2 个答案: