我有一个class A
,它为它的一个字段使用堆内存分配。类A被实例化并存储为另一个类中的指针字段(class B
。
当我处理完B类的对象时,我调用delete
,我假设它调用析构函数...但是这是否也调用了A类的析构函数呢?
编辑:
从答案中,我认为(如果不正确,请编辑):
B的实例的
delete
调用B::~B();调用A::~A();
A::~A
的object;delete
A的所有堆分配的成员变量。存储B类的实例的内存块被返回到堆-当使用new时,它首先在堆上分配一个内存块,然后调用构造函数对其进行初始化,现在在调用所有析构函数完成对象之后,对象所在的块被返回到堆。发布于 2009-03-24 14:32:34
A的析构函数将在其生命周期结束时运行。如果您想要释放它的内存并运行析构函数,那么如果它是在堆上分配的,则必须将其删除。如果它是在堆栈上分配的,这会自动发生(即当它超出范围时;请参阅RAII)。如果它是一个类的成员(不是一个指针,而是一个完整的成员),那么当包含的对象被销毁时就会发生这种情况。
class A
{
char *someHeapMemory;
public:
A() : someHeapMemory(new char[1000]) {}
~A() { delete[] someHeapMemory; }
};
class B
{
A* APtr;
public:
B() : APtr(new A()) {}
~B() { delete APtr; }
};
class C
{
A Amember;
public:
C() : Amember() {}
~C() {} // A is freed / destructed automatically.
};
int main()
{
B* BPtr = new B();
delete BPtr; // Calls ~B() which calls ~A()
C *CPtr = new C();
delete CPtr;
B b;
C c;
} // b and c are freed/destructed automatically
在上面的示例中,每个delete和delete[]都是必需的。并且在我没有使用它的地方,不需要删除(或者实际上可以使用)。
auto_ptr
、unique_ptr
和shared_ptr
等。可以让这种终生管理变得更容易:
class A
{
shared_array<char> someHeapMemory;
public:
A() : someHeapMemory(new char[1000]) {}
~A() { } // someHeapMemory is delete[]d automatically
};
class B
{
shared_ptr<A> APtr;
public:
B() : APtr(new A()) {}
~B() { } // APtr is deleted automatically
};
int main()
{
shared_ptr<B> BPtr = new B();
} // BPtr is deleted automatically
发布于 2009-03-24 14:36:12
在由new分配的指针上调用delete时,将调用指向的对象的析构函数。
A * p = new A;
delete p; // A:~A() called for you on obkect pointed to by p
发布于 2009-03-24 14:32:23
它被命名为“析构函数”,而不是“解构函数”。
在每个类的析构函数中,您必须删除所有其他分配了new的成员变量。
编辑:澄清以下内容:
说你有
struct A {}
class B {
A *a;
public:
B () : a (new A) {}
~B() { delete a; }
};
class C {
A *a;
public:
C () : a (new A) {}
};
int main () {
delete new B;
delete new C;
}
分配B的一个实例然后删除是干净的,因为B在内部分配的内容也会在析构函数中被删除。
但是类C的实例会泄漏内存,因为它分配了一个它不会释放的A的实例(在这种情况下,C甚至没有析构函数)。
https://stackoverflow.com/questions/677653
复制相似问题