首先转载一下牛人的文章,我觉得写得不错：http://www.cppblog.com/lovedday/archive/2008/06/03/52060.html
内容如下：
In order to understand "delete this" :
First Step------dive into "delete p"
delete p 执行了哪两个步骤？
delete p 是一个两步的过程：调用析构函数，然后释放内存。delete p产生的代码看上去是这样的（假设是Fred*类型的）：
// 原始码：delete p;
if (p != NULL)
{
p->~Fred();
operator delete(p);
}
p->~Fred() 语句调用 p 指向的Fred 对象的析构函数。
operator delete(p) 语句调用内存释放原语 void operator delete(void* p)。
Second Step-------"delete this"
成员函数调用delete this合法吗？
只要你小心，一个对象请求自杀(delete this)，是可以的。
以下是我对“小心”的定义：
你必须100%的确定，this对象是用 new分配的（不是用new[]，也不是用定位放置 new，也不是一个栈上的局部对象，也不是全局的，也不是另一个对象的成员，而是明白的普通的new）。
你必须100%的确定，该成员函数是this对象最后调用的的成员函数。
你必须100%的确定，剩下的成员函数（delete this之后的）不接触到 this对象任何一块（包括调用任何其他成员函数或访问任何数据成员）。
你必须 100%的确定，在delete this之后不再去访问this指针。换句话说，你不能去检查它，将它和其他指针比较，和 NULL比较，打印它，转换它，对它做任何事。
自然，对于这种情况还要习惯性地告诫：当你的指针是一个指向基类类型的指针，而没有虚析构函数时（也不可以 delete this）。
注意：因为是在类成员函数里面delete this的，所以在此语句以后，不能访问任何的成员变量及虚函数，否则一定非法。
我考虑到了另一种情况：如果父类有个成员函数DeleteMyself,专门做这种自杀行为，而子类没有这个函数：
#include <iostream>
using namespace std;
class Animal
{
public:
Animal();
~Animal();
virtual void Shout();
void Name();
virtual void DeleteMyself();
private:
bool mbOld;
};
Animal::Animal():mbOld(false)
{
cout<<"Animal Born"<<endl;
}
Animal::~Animal()
{
mbOld = false;
cout<<"Animal time was gone!"<<endl;
}
void Animal::Shout()
{
cout<<"I am animal"<<endl;
}
void Animal::Name()
{
cout<<"My name is animal"<<endl;
}
void Animal::DeleteMyself()
{
delete this;
}
class Dog : public Animal
{
public:
Dog();
virtual ~Dog();
void Shout();
void Name();
};
Dog::Dog()
{
cout<<"Dog born"<<endl;
}
Dog::~Dog()
{
cout<<"Dog time was gone"<<endl;
}
void Dog::Shout()
{
cout<<"I am dog"<<endl;
}
void Dog::Name()
{
cout<<"My name is dog"<<endl;
}
void main()
{
Animal* pMyAnimal = new Dog;
pMyAnimal->Shout();
pMyAnimal->Name();
pMyAnimal->DeleteMyself();
cin.get();
}
那么结果会是什么样子呢？父类的析构函数如果是虚函数会怎样呢？ 子类在内存中内否释放干净呢？
首先看一下结果，父类的析构函数非虚，结果是：
Animal Born
Dog born
I am dog
My name is animal
Animal time was gone!
等于说：子类还是没有释放。
当父类的析构函数为虚时，结果是：
Animal Born
Dog born
I am dog
My name is animal
Dog time was gone
Animal time was gone!
那么看来子类的析构函数是调用了，但是子类的内存释放干净了吗？这里我不敢肯定子类的内存释放干净了，所以保险的做法是，在子类中重写DeleteMyself。