Files的delete替代FIle的delete delete this file

转载

mob64ca1403528a 2024-03-26 13:26:28

文章标签 delete null c 子类析构函数 文章分类 架构后端开发

delete this--对象请求自杀

版本：0.1

最后修改：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--以保证第三方能够将分配的内存回收；

------------------------ 
 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,专门做这种自杀行为，而子类没有这个函数：

1. #include <iostream>  
2. using namespace std;  
3.   
4. class Animal  
5. {  
6. public:  
7.     Animal();  
8.     ~Animal();  
9. virtual void Shout();  
10. void Name();  
11. virtual void DeleteMyself();  
12. private:  
13. bool mbOld;  
14. };  
15. Animal::Animal():mbOld(false)  
16. {  
17. "Animal Born"<<endl;  
18. }  
19. Animal::~Animal()  
20. {  
21. false;  
22. "Animal time was gone!"<<endl;  
23. }  
24. void Animal::Shout()  
25. {  
26. "I am animal"<<endl;  
27. }  
28. void Animal::Name()  
29. {  
30. "My name is animal"<<endl;  
31. }  
32. void Animal::DeleteMyself()  
33. {  
34. delete this;  
35. }  
36. class Dog : public Animal  
37. {  
38. public:  
39.     Dog();  
40. virtual ~Dog();  
41. void Shout();  
42. void Name();  
43. };  
44. Dog::Dog()  
45. {  
46. "Dog born"<<endl;  
47. }  
48. Dog::~Dog()  
49. {  
50. "Dog time was gone"<<endl;  
51. }  
52. void Dog::Shout()  
53. {  
54. "I am dog"<<endl;  
55. }  
56. void Dog::Name()  
57. {  
58. "My name is dog"<<endl;  
59. }  
60. void main()  
61. {  
62. new Dog;  
63.     pMyAnimal->Shout();  
64.     pMyAnimal->Name();  
65.     pMyAnimal->DeleteMyself();  
66.   
67.     cin.get();  
68. }

那么结果会是什么样子呢？父类的析构函数如果是虚函数会怎样呢？子类在内存中内否释放干净呢？

首先看一下结果，父类的析构函数非虚，结果是：

Animal Born

Dog born

I am dog

My name is animal

Animal time was gone!

等于说：子类还是没有释放。

当父类的析构函数为虚时，结果是：

Animal Born

Dog born

I am dog