blocks|key|349643|text|不是的。指针将被删除。应该在B的析构函数中对A+explicit调用delete。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|349644|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

No. the pointer will be deleted. You should call the delete on A explicit in the destructor of B.

blocks|key|3122271|text|它被命名为“析构函数”，而不是“解构函数”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3122272|在每个类的析构函数中，您必须删除所有其他分配了new的成员变量。|3122273|编辑:澄清以下内容：|3122274|说你有|3122275|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;
}|code-block|syntax|javascript|3122276|分配B的一个实例然后删除是干净的，因为B在内部分配的内容也会在析构函数中被删除。|3122277|但是类C的实例会泄漏内存，因为它分配了一个它不会释放的A的实例(在这种情况下，C甚至没有析构函数)。|3122278|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

It is named "destructor", not "deconstructor".

Inside the destructor of each class, you have to delete all other member variables that have been allocated with new.

edit: To clarify:

Say you have

<pre><code>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;
}
</code></pre>

Allocating an instance of B and then deleting is clean, because what B allocates internally will also be deleted in the destructor.

But instances of class C will leak memory, because it allocates an instance of A which it does not release (in this case C does not even have a destructor).

blocks|key|346148|text|A的析构函数将在其生命周期结束时运行。如果您想要释放它的内存并运行析构函数，那么如果它是在堆上分配的，则必须将其删除。如果它是在堆栈上分配的，这会自动发生(即当它超出范围时；请参阅RAII)。如果它是一个类的成员(不是一个指针，而是一个完整的成员)，那么当包含的对象被销毁时就会发生这种情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|346149|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|code-block|syntax|javascript|346150|在上面的示例中，每个delete和delete[]都是必需的。并且在我没有使用它的地方，不需要删除(或者实际上可以使用)。|346151|auto_ptr、unique_ptr和shared_ptr等。可以让这种终生管理变得更容易：|offset|length|style|CODE|346152|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+BPtr+=+new+B();
}+//+BPtr+is+deleted+automatically|346153|entityMap^0|0|0|0|0|8|9|A|K|A|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]|$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

The destructor of A will run when its lifetime is over. If you want its memory to be freed and the destructor run, you have to delete it if it was allocated on the heap. If it was allocated on the stack this happens automatically (i.e. when it goes out of scope; see RAII). If it is a member of a class (not a pointer, but a full member), then this will happen when the containing object is destroyed.

<pre><code>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
</code></pre>

In the above example, every delete and delete[] is needed. And no delete is needed (or indeed able to be used) where I did not use it.

<code>auto_ptr</code>, <code>unique_ptr</code> and <code>shared_ptr</code> etc... are great for making this lifetime management much easier:

<pre><code>class A
{
 shared_array&lt;char&gt; someHeapMemory;
public:
 A() : someHeapMemory(new char[1000]) {}
 ~A() { } // someHeapMemory is delete[]d automatically
};

class B
{
 shared_ptr&lt;A&gt; APtr;
public:
 B() : APtr(new A()) {}
 ~B() { } // APtr is deleted automatically
};

int main()
{
 shared_ptr&lt;B&gt; BPtr = new B();
} // BPtr is deleted automatically
</code></pre>

blocks|key|3335222|text|你应该自己在B的析构函数中删除A。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3335223|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You should delete A yourself in the destructor of B.

blocks|key|3335225|text|class+B
{
public:
++++B()
++++{
+++++++p+=+new+int[1024];++
++++}
++++virtual+~B()
++++{
++++++++cout<<"B+destructor"<<endl;
++++++++//p+will+not+be+deleted+EVER+unless+you+do+it+manually.
++++}
++++int+*p;
};


class+D+:+public+B
{
public:
++++virtual+~D()
++++{
++++++++cout<<"D+destructor"<<endl;
++++}
};|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3335226|当你这样做的时候：|unstyled|3335227|B+*pD+=+new+D();
delete+pD;|3335228|只有当基类具有virtual关键字时，才会调用析构函数。|3335229|如果你没有一个虚拟的析构函数，只会调用~B()。但是因为你有一个虚拟的析构函数，所以首先调用~D()，然后调用~B().|3335230|在堆上分配的B或D的任何成员都不会被释放，除非您显式删除它们。删除它们也会调用它们的析构函数。|3335231|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>class B
{
public:
 B()
 {
 p = new int[1024]; 
 }
 virtual ~B()
 {
 cout&lt;&lt;"B destructor"&lt;&lt;endl;
 //p will not be deleted EVER unless you do it manually.
 }
 int *p;
};


class D : public B
{
public:
 virtual ~D()
 {
 cout&lt;&lt;"D destructor"&lt;&lt;endl;
 }
};
</code></pre>

When you do:

<pre><code>B *pD = new D();
delete pD;
</code></pre>

The destructor will be called only if your base class has the virtual keyword. 

Then if you did not have a virtual destructor only ~B() would be called. But since you have a virtual destructor, first ~D() will be called, then ~B().

No members of B or D allocated on the heap will be deallocated unless you explicitly delete them. And deleting them will call their destructor as well.

blocks|key|347043|text|如果你有一个常用的指针(A*)，那么析构函数不会被调用(+A实例的内存也不会被释放)，除非你在B的析构函数中显式地执行delete。如果你想要自动销毁，可以看看像auto_ptr这样的智能指针。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|347044|entityMap^0|C|2|T|1|1B|1|1N|6|29|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|G|$]]

If you have a usual pointer (<code>A*</code>) then the destructor will not be called (and memory for <code>A</code> instance will not be freed either) unless you do <code>delete</code> explicitly in <code>B</code>'s destructor. If you want automatic destruction look at smart pointers like <code>auto_ptr</code>.

blocks|key|3335264|text|类A的对象的析构函数仅在为该对象调用delete时才会调用。确保删除B类的析构函数中的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3335265|有关在对象上调用delete时发生的情况的更多信息，请参阅：http://www.parashift.com/c%2B%2B-faq-lite/freestore-mgmt.html#faq-16.9|offset|length|3335266|entityMap|0|LINK|mutability|MUTABLE|url|http://www.parashift.com/c%2B%2B-faq-lite/freestore-mgmt.html#faq-16.9^0|0|U|1U|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

The destructor for the object of class A will only be called if delete is called for that object. Make sure to delete that pointer in the destructor of class B.

For a little more information on what happens when delete is called on an object, see:
<a href="http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.9" rel="nofollow noreferrer">http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.9</a>

blocks|key|344812|text|在由new分配的指针上调用delete时，将调用指向的对象的析构函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|344813|A+*+p+=+new+A;

delete+p;++++//+A:~A()+called+for+you+on+obkect+pointed+to+by+p|code-block|syntax|javascript|344814|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

When you call delete on a pointer allocated by new, the destructor of the object pointed to will be called.

<pre><code>A * p = new A;

delete p; // A:~A() called for you on obkect pointed to by p
</code></pre>

blocks|key|3335326|text|不，它不会为类A调用析构函数，您应该显式调用它(就像PoweRoy告诉的那样)，删除示例中的行'delete+ptr;‘以进行比较...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3335327|++#include+<iostream>

++class+A
++{
+++++public:
++++++++A(){};
++++++++~A();
++};

++A::~A()
++{
+++++std::cout+<<+"Destructor+of+A"+<<+std::endl;
++}

++class+B
++{
+++++public:
++++++++B(){ptr+=+new+A();};
++++++++~B();
+++++private:
++++++++A*+ptr;
++};

++B::~B()
++{
+++++delete+ptr;
+++++std::cout+<<+"Destructor+of+B"+<<+std::endl;
++}

++int+main()
++{
+++++B*+b+=+new+B();
+++++delete+b;
+++++return+0;
++}|code-block|syntax|javascript|3335328|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

no it will not call destructor for class A, you should call it explicitly (like PoweRoy told), delete line 'delete ptr;' in example to compare ...

<pre><code> #include &lt;iostream&gt;

 class A
 {
 public:
 A(){};
 ~A();
 };

 A::~A()
 {
 std::cout &lt;&lt; "Destructor of A" &lt;&lt; std::endl;
 }

 class B
 {
 public:
 B(){ptr = new A();};
 ~B();
 private:
 A* ptr;
 };

 B::~B()
 {
 delete ptr;
 std::cout &lt;&lt; "Destructor of B" &lt;&lt; std::endl;
 }

 int main()
 {
 B* b = new B();
 delete b;
 return 0;
 }
</code></pre>

blocks|key|3335356|text|你有类似这样的东西|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3335357|class+B
{
+++A+*+a;
}
B+*+b+=+new+B;
b->a+=+new+A;|code-block|syntax|javascript|3335358|如果您随后调用delete+b;，则a不会发生任何变化，并且会发生内存泄漏。尝试记住delete+b->a;不是一个好的解决方案，但还有一些其他的解决方案。|offset|length|style|CODE|3335359|B::~B()+{delete+a;}|3335360|这是B的析构函数，它将删除a。(如果a为0，则该删除不执行任何操作。如果a不是0，但没有从new指向内存，则会导致堆损坏。)|3335361|auto_ptr<A>+a;
...
b->a.reset(new+A);|3335362|这样你就不会将a作为指针，而是一个auto_ptr<>+(shared_ptr<>也可以，或者其他智能指针)，当b为时，它会被自动删除。|3335363|这两种方法中的任何一种都能很好地工作，我使用了这两种方法。|3335364|entityMap^0|0|0|7|9|16|C|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|X|$]]

You have something like

<pre><code>class B
{
 A * a;
}
B * b = new B;
b-&gt;a = new A;
</code></pre>

If you then call <code>delete b;</code>, nothing happens to a, and you have a memory leak. Trying to remember to <code>delete b-&gt;a;</code> is not a good solution, but there are a couple of others.

<pre><code>B::~B() {delete a;}
</code></pre>

This is a destructor for B that will delete a. (If a is 0, that delete does nothing. If a is not 0 but doesn't point to memory from new, you get heap corruption.)

<pre><code>auto_ptr&lt;A&gt; a;
...
b-&gt;a.reset(new A);
</code></pre>

This way you don't have a as a pointer, but rather an auto_ptr&lt;> (shared_ptr&lt;> will do as well, or other smart pointers), and it is automatically deleted when b is.

Either of these ways works well, and I've used both.

blocks|key|3335389|text|我想知道为什么我的类的析构函数没有被调用。原因是我忘记包含该类的定义(#include+"class.h")。我只有一个像"class+A;“这样的声明，编译器对它很满意，让我调用"delete”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3335390|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I was wondering why my class' destructor was not called. The reason was that I had forgot to include definition of that class (#include "class.h"). I only had a declaration like "class A;" and the compiler was happy with it and let me call "delete".

I have an <code>class A</code> which uses a heap memory allocation for one of its fields. Class A is instantiated and stored as a pointer field in another class (<code>class B</code>.
When I'm done with an object of class B, I call <code>delete</code>, which I assume calls the destructor... But does this call the destructor of class A as well?
<h3>Edit:</h3>
From the answers, I take that (please edit if incorrect):
<ol>
<li><code>delete</code> of an instance of B calls B::~B();</li>
<li>which calls <code>A::~A();</code></li>
<li><code>A::~A</code> should explicitly <code>delete</code> all heap-allocated member variables of the A object;</li>
<li>Finally the memory block storing said instance of class B is returned to the heap - when new was used, it first allocated a block of memory on heap, then invoked constructors to initialize it, now after all destructors have been invoked to finalize the object the block where the object resided is returned to the heap.</li>
</ol>

Does delete on a pointer to a subclass call the base class destructor?

编译器

我有一个class A，它为它的一个字段使用堆内存分配。类A被实例化并存储为另一个类中的指针字段(class B。当我处理完B类的对象时，我调用delete，我假设它调用析构函数...但是这是否也调用了A类的析构函数呢？编辑：从答案中，我认为(如果不正确，请编辑)：B的实例的delete调用B：：~B()；调用A::~...

问在指向子类的指针上删除会调用基类析构函数吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在指向子类的指针上删除会调用基类析构函数吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在指向子类的指针上删除会调用基类析构函数吗？
EN