from : http://www.cppblog.com/xmli/archive/2009/08/18/93683.html
delete this--对象请求自杀
最后修改:2009-08-18
撰写:李现民
第一次见delete this的时候,没觉得这是一项会有什么特殊作用的技术,因此也就没有特别关注。
昨日在sourcemaking.com上看state模式之c++实现的时候,看到它在状态转换的时候使用了delete this,感觉似乎还不错。
作为一种“禁术”,使用的时候必须要相当小心才行,《C++ FAQ》里提到所谓“小心”至少包括以下几个方面:
this对象是必须是用 new操作符分配的(而不是用new[],也不是用placement new,也不是局部对象,也不是global对象);
delete this后,不能访问该对象任何的成员变量及虚函数(delete this回收的是数据,这包括对象的数据成员以及vtable,不包括函数代码);
delete this后,不能再访问this指针。换句话说,你不能去检查它、将它和其他指针比较、和 NULL比较、打印它、转换它,以及其它的任何事情;
个人认为保证以上禁忌列表基本手段可以包括:
将析构函数私有化(如果有子类,则protected化,保证子类能够正确继承)--以保证对象必须使用new在堆上分配内存;
提供(可以在仅仅在基类中)Destroy(void)函数,里面仅有一句delete this--以保证第三方能够将分配的内存回收;
------------------------
from : http://blog.csdn.net/outmanlee/article/details/7435931
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。