这个问题有点难，delete 的是整个对象还是该对象的A部分？？

Question

class A
{...}
class B:public class A
{...}
main() 
{A* ptr=new B; 
 delete ptr;}
这里，delete 的是整个对象还是该对象的A部分？？
还有，虚拟析构函数怎么回事？（MFC常用）

Answer 1

首先，delete会执行析构函数，在这里，如果~A为虚函数，那么调用的析构函数为子类的，也就是~B，调用完派生类的析构函数后会，跟着自动调用基类的析构函数~A。
最后，delete释放掉指针指向的内存块，其大小是sizeof(B)。
因此，如果你在析构函数如果没有特别的操作，例如释放内存，释放资源，即使你基类析构函数不是虚函数，也不会产生内存泄漏。

Answer 2

1. delete ptr,是指释放堆内存,所以不存在是A部份还是B部份.其堆内存的大小是sizeof(B).
2. delete ptr,是否能达到设计者的要求,取决于A类中的destructor是不是virtual的.举例:
class A
{
  char* p;
public:
  A(){ p=new char[10];}
 ~A() {delete p;}
};class B : public A
{
   char* q;
public:
   B(){q=new char[10];}
  ~B(){delete q;}
};main()
{
  A* ptr=new B;
  delete ptr;
}
将出现B类的q指针所指的堆内存没有释放. 如果A是
class A
{
  char* p;
public:
  A(){ p=new char[10];}
  virtual ~A() {delete p;}
};将不会出现错误,A类的p指针和B类的q指针均得到释放.

Answer 3

哈哈,用事实说话.看看事例程序
#include <iostream.h>
class A
{
char * p;
public:
A()
{
p = new char[5];
cout<<"new A::p!"<<endl;
}
~A()
{
delete p;
cout<<"delete A::p!"<<endl;
}};
class B:public A
{
char * p;
public:
B()
{
p = new char[5];
    cout<<"new B::p"<<endl;
}
~B()
{
delete p;
cout<<"delete B::p"<<endl;
}
};
void main()
{
A * ptr = new B;
delete ptr;
}
输出是
new A::p!
new B::p
delete A::p!如果改成虚拟的.输出为
new A::p!
new B::p
delete B::p
delete A::p!

Answer 4

再看以下的例子
只是关于B的.A和上面的是一样的.A析沟不是虚函数
char * a;
#include <string.h>
class B:public A
{
char * p;
public:
B()
{
p = new char[100];
memset(p,'a',100);
a = p;
    cout<<"new B::p"<<endl;
}
~B()
{
delete p;
cout<<"delete B::p"<<endl;
}
};
void main()
{
A * ptr = new B;
       delete ptr;

       for(int i=0;i<100;i++)
cout<<a[i];
cout<<endl;
}
这个输出就可以把a[i]给输出来,可见内存析漏了.
而改成虚函数的析沟函数后,就会发现a指向的内存被清楚了,OK?