Question

我有两个课程：Foo和Bar。

在Main我创建1个Foo对象。然后我从createBars()调用方法Foo。此方法创建3个Bar个对象。在Main我想删除Foo对象和该Foo对象生成的所有对象。

怎么做？

代码：

int Main()
{
     Foo foo;
     foo.createBars();
}

void Foo::createBars()
{
     Bar bar1;
     Bar bar2;
     Bar bar3;
}

Answer 1

int Main()
{
   Foo foo; // instance created of Foo class
   foo.createBars(); // calling method createBars()

} // automatically, the instance foo goes out of scope, thus getting destructed

void Foo::createBars()
{
   Bar bar1; // create instance of class Bar bar1
   Bar bar2; // create instance of class Bar bar2
   Bar bar3; // create instance of class Bar bar3
} // all the instances bar1, bar2 and bar3 go out of scope and get destructed automatically

您没有在堆中分配任何内容，因此您无需取消分配任何内容。

[编辑]

当您不确定是否调用了对象的构造函数/析构函数时，您始终可以在其中添加cout并查找。

以下是您的代码示例：

#include <iostream>     // std::cout

class Bar {
public:
    Bar() {
        std::cout << "Constructor of Bar\n";
    }

    ~Bar() {
        std::cout << "Destructor of Bar\n";
    }
};

class Foo {
public:
    Foo() {
        std::cout << "Constructor of Foo\n";
    }

    ~Foo() {
        std::cout << "Destructor of Foo\n";
    }

    void createBars()
    {
         Bar bar1;
         Bar bar2;
         Bar bar3;
    }
};

int main()
{
     Foo foo;
     std::cout << "After the Foo foo;\n";
     foo.createBars();
     std::cout << "After the foo.createBars();\n";
     return 0;
}

输出：

Constructor of Foo
After the Foo foo;
Constructor of Bar
Constructor of Bar
Constructor of Bar
Destructor of Bar
Destructor of Bar
Destructor of Bar
After the foo.createBars();
Destructor of Foo

斯宾斯指出：

堆是一种技术性。这里重要的是区分动态存储持续时间。它是例如可以在堆栈上动态分配内存。

只有当您使用delete 动态分配对象时，才需要手动new个对象。否则，当它们超出范围时，它们将被自动取消分配。

此处bar1，bar2和bar3是该函数的局部变量。

Answer 2

只有在使用delete时才需要

new。

在你的情况下，你只是声明Bar对象，不需要删除，他们将在foo范围的末尾“删除”自己。

如何删除在该对象内创建的对象和对象？

2 个答案: