C++ 我必须手动解构所有对象吗_C++_Class

C++ 我必须手动解构所有对象吗

c++ class

C++ 我必须手动解构所有对象吗,c++,class,C++,Class,我创建了一个名为BST的类，它有一个成员根。我知道当我调用解构器到类BST时，它会删除根并释放该类占用的内存我想知道解构器是否会解构所有与BST对象相关的节点。也就是根的左子级和右子级，以及它们的左子级和右子级等等我的猜测是否定的。在这种情况下，我想我将不得不进行后序遍历并手动删除每个节点。有没有办法一次就做完。无需在树节点周围走动 #ifndef BST_H #define BST_H #include "bst.h" #include <stdio.h> #include&l

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

我想知道解构器是否会解构所有与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

\ifndef BST\u H
#定义BST_H
#包括“bst.h”
#包括
#包括
bst级
{
受保护的：
结构节点{
节点*p；
节点*lc；
节点*rc；
int键；
节点（int x，node*p=nullptr，node*lc=nullptr，node*rc=nullptr）：键（x）{
}
~node（）{
标准：coutx）{
y=y->lc；
}
否则{
y=y->rc；
}
}
如果（p==nil）{
这个->根=k；
k->lc=此->无；
k->rc=此->无；
k->p=此->无；
}
否则如果（p->键>x）{
p->lc=k；
p->lc->p=p；
k=p->lc；
k->lc=此->无；
k->rc=此->无；
}
否则{
p->rc=k；
p->rc->p=p；
k=p->rc；
k->lc=此->无；
k->rc=此->无；
}
}
void bst:：按顺序（节点*x）{
如果（x！=nil）{
此->按顺序（x->lc）；
printf（“%d%c”，x->key，“\t”）；
此->按顺序（x->rc）；
}
}
void bst:：按顺序（）{
此->按顺序排列（此->根）；
printf（“%c”，“\n”）；
}
void bst:：预订单（节点*x）{
如果（x！=此->无）{
printf（“%d%c”，x->key，“\t”）；
预订单（x->lc）；
预订单（x->rc）；
}
}
无效bst:：预订单（）{
预订单（此->根）；
printf（“%c”，“\n”）；
}

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

在您所展示的实现中，

~bst

析构函数基本上是空的（日志记录不起作用），它根本不释放任何节点

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

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

要么：

对

~节点

析构函数进行编码以删除其直接子节点。然后

~bst

析构函数可以删除其

根

节点，并且它下面的所有其他节点都将被递归删除

使用智能指针，例如

std:：unique_ptr

，而不是原始指针。让编译器为您完成所有工作

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

在您所展示的实现中，

~bst

析构函数基本上是空的（日志记录不起作用），它根本不释放任何节点

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

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

要么：

对

~节点

析构函数进行编码以删除其直接子节点。然后

~bst

析构函数可以删除其

根

节点，并且它下面的所有其他节点都将被递归删除

使用智能指针，例如

std:：unique_ptr

，而不是原始指针。让编译器为您完成所有工作

“我必须手动解构所有对象吗？”

是的，因为C/C++不跟踪内存，所以您告诉它您将自行管理，这是使用

new

和/或

malloc

隐含的意思

如果您愿意，可以针对不同的用例。但是，除此之外，您必须始终将每个分配（

new

）与正好1个释放（

delete

）配对

“我想知道，解构器会解构所有与BST对象相关的节点吗？”

不，因为你没有告诉我

你应该：

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

~node（）
{
std:：cout“我必须手动解构所有对象吗？”
是的，因为C/C++不跟踪内存，所以您告诉它您将自行管理，这是使用new
和/或malloc
隐含的意思
如果您愿意，可以针对不同的用例。但是，除此之外，您必须始终将每个分配（new
）与正好1个释放（delete
）配对
“我想知道，解构器会解构所有与BST对象相关的节点吗？”
不，因为你没有告诉我
你应该：
~node()
{
    std::cout<<"decontrucotr node";
    delete lc;
    delete rc;
}

~node（）
{
std:：coutQuick问题：你研究过STL的智能指针吗？如果你被要求使用原始指针或不能使用C++11或更高版本，我很抱歉，但是如果你没有，看看智能指针。内存管理可能是一个真正的负担。@Wikiti我想你的意思是，对于每一个新的，应该有一个删除。听起来可能像n这很重要，但有时语言很重要。